prepare actix-files release 0.6.0-beta.12

closes #2389

.cargo/config.toml

@@ -1,8 +1,14 @@
 [alias]
-chk = "check --workspace --all-features --tests --examples --bins"
-lint = "clippy --workspace --tests --examples"
-ci-min = "hack check --workspace --no-default-features"
-ci-min-test = "hack check --workspace --no-default-features --tests --examples"
-ci-default = "hack check --workspace"
-ci-full = "check --workspace --bins --examples --tests"
-ci-test = "test --workspace --all-features --no-fail-fast"
+lint = "clippy --workspace --tests --examples --bins -- -Dclippy::todo"
+lint-all = "clippy --workspace --all-features --tests --examples --bins -- -Dclippy::todo"
+
+# lib checking
+ci-check-min = "hack --workspace check --no-default-features"
+ci-check-default = "hack --workspace check"
+ci-check-default-tests = "check --workspace --tests"
+ci-check-all-feature-powerset="hack --workspace --feature-powerset --skip=__compress,io-uring check"
+ci-check-all-feature-powerset-linux="hack --workspace --feature-powerset --skip=__compress check"
+
+# testing
+ci-doctest-default = "test --workspace --doc --no-fail-fast -- --nocapture"
+ci-doctest = "test --workspace --all-features --doc --no-fail-fast -- --nocapture"

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [robjtede]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -33,5 +33,5 @@ Please search on the [Actix Web issue tracker](https://github.com/actix/actix-we
 ## 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:
+- Rust Version (I.e, output of `rustc -V`):
+- Actix Web Version:

.github/ISSUE_TEMPLATE/config.yml

@@ -1,15 +1,8 @@
 blank_issues_enabled: true
 contact_links:
-  - name: GitHub Discussions
-    url: https://github.com/actix/actix-web/discussions
-    about: Actix Web Q&A
-  - name: Gitter chat (actix-web)
-    url: https://gitter.im/actix/actix-web
-    about: Actix Web Q&A
-  - name: Gitter chat (actix)
-    url: https://gitter.im/actix/actix
-    about: Actix (actor framework) Q&A
   - name: Actix Discord
     url: https://discord.gg/NWpN5mmg3x
     about: Actix developer discussion and community chat
-
+  - name: GitHub Discussions
+    url: https://github.com/actix/actix-web/discussions
+    about: Actix Web Q&A

.github/PULL_REQUEST_TEMPLATE.md

@@ -8,7 +8,7 @@ PR_TYPE
 
 
 ## PR Checklist
-<!-- Check your PR fulfills the following items. ->>
+<!-- Check your PR fulfills the following items. -->
 <!-- For draft PRs check the boxes as you complete them. -->
 
 - [ ] Tests for the changes have been added / updated.

.github/workflows/ci-master.yml

@@ -0,0 +1,66 @@
+name: CI (master only)
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  ci_feature_powerset_check:
+    name: Verify Feature Combinations
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with: { command: generate-lockfile }
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.2.0
+
+      - name: Install cargo-hack
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-hack
+
+      - name: check feature combinations
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-all-feature-powerset }
+      
+      - name: check feature combinations
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-all-feature-powerset-linux }
+
+  coverage:
+    name: coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with: { command: generate-lockfile }
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.2.0
+
+      - name: Generate coverage file
+        run: |
+          cargo install cargo-tarpaulin --vers "^0.13"
+          cargo tarpaulin --workspace --features=rustls,openssl --out Xml --verbose
+      - name: Upload to Codecov
+        uses: codecov/codecov-action@v1
+        with: { file: cobertura.xml }

.github/workflows/ci.yml

@@ -14,9 +14,9 @@ jobs:
         target:
           - { name: Linux, os: ubuntu-latest, triple: x86_64-unknown-linux-gnu }
           - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin }
-          - { name: Windows, os: windows-latest, triple: x86_64-pc-windows-msvc }
+          - { name: Windows, os: windows-2022, triple: x86_64-pc-windows-msvc }
         version:
-          - 1.46.0 # MSRV
+          - 1.52.0 # MSRV
           - stable
           - nightly
 
@@ -24,12 +24,16 @@ jobs:
     runs-on: ${{ matrix.target.os }}
 
     env:
+      CI: 1
+      CARGO_INCREMENTAL: 0
       VCPKGRS_DYNAMIC: 1
 
     steps:
       - uses: actions/checkout@v2
 
       # install OpenSSL on Windows
+      # TODO: GitHub actions docs state that OpenSSL is
+      # already installed on these Windows machines somewhere
       - name: Set vcpkg root
         if: matrix.target.triple == 'x86_64-pc-windows-msvc'
         run: echo "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" | Out-File -FilePath $env:GITHUB_ENV -Append
@@ -44,17 +48,9 @@ jobs:
           profile: minimal
           override: true
 
-      - name: Install ${{ matrix.version }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.version }}-${{ matrix.target.triple }}
-          profile: minimal
-          override: true
-
       - name: Generate Cargo.lock
         uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
+        with: { command: generate-lockfile }
       - name: Cache Dependencies
         uses: Swatinem/rust-cache@v1.2.0
 
@@ -66,62 +62,60 @@ jobs:
 
       - name: check minimal
         uses: actions-rs/cargo@v1
-        with:
-          command: hack
-          args: check --workspace --no-default-features
+        with: { command: ci-check-min }
 
-      - name: check minimal + tests
+      - name: check default
         uses: actions-rs/cargo@v1
-        with:
-          command: hack
-          args: check --workspace --no-default-features --tests --examples
-
-      - name: check full
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --workspace --bins --examples --tests
+        with: { command: ci-check-default }
 
       - name: tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace --all-features --no-fail-fast -- --nocapture
-            --skip=test_h2_content_length
-            --skip=test_reading_deflate_encoding_large_random_rustls
-
-      - 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.target.os == 'ubuntu-latest'
-          && matrix.version == 'stable'
-          && github.ref == 'refs/heads/master'
+        timeout-minutes: 60
         run: |
-          cargo install cargo-tarpaulin --vers "^0.13"
-          cargo tarpaulin --out Xml --verbose
-      - name: Upload to Codecov
-        if: >
-          matrix.target.os == 'ubuntu-latest'
-          && matrix.version == 'stable'
-          && github.ref == 'refs/heads/master'
-        uses: codecov/codecov-action@v1
-        with:
-          file: cobertura.xml
+          cargo test --lib --tests -p=actix-router --all-features
+          cargo test --lib --tests -p=actix-http --all-features
+          cargo test --lib --tests -p=actix-web --features=rustls,openssl -- --skip=test_reading_deflate_encoding_large_random_rustls
+          cargo test --lib --tests -p=actix-web-codegen --all-features
+          cargo test --lib --tests -p=awc --all-features
+          cargo test --lib --tests -p=actix-http-test --all-features
+          cargo test --lib --tests -p=actix-test --all-features
+          cargo test --lib --tests -p=actix-files
+          cargo test --lib --tests -p=actix-multipart --all-features
+          cargo test --lib --tests -p=actix-web-actors --all-features
+
+      - name: tests (io-uring)
+        if: matrix.target.os == 'ubuntu-latest'
+        timeout-minutes: 60
+        run: >
+          sudo bash -c "ulimit -Sl 512
+          && ulimit -Hl 512
+          && PATH=$PATH:/usr/share/rust/.cargo/bin
+          && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo test --lib --tests -p=actix-files --all-features"
 
       - name: Clear the cargo caches
         run: |
-          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
+          cargo install cargo-cache --version 0.6.3 --no-default-features --features ci-autoclean
           cargo-cache
+
+  rustdoc:
+    name: doc tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust (nightly)
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with: { command: generate-lockfile }
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.3.0
+
+      - name: doc tests
+        uses: actions-rs/cargo@v1
+        timeout-minutes: 60
+        with: { command: ci-doctest }

.github/workflows/clippy-fmt.yml

@@ -36,4 +36,4 @@ jobs:
         uses: actions-rs/clippy-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace --tests --all-features
+          args: --workspace --all-features --tests

.gitignore

@@ -16,3 +16,6 @@ guide/build/
 
 # Configuration directory generated by CLion
 .idea
+
+# Configuration directory generated by VSCode
+.vscode

CODE_OF_CONDUCT.md

@@ -8,19 +8,19 @@ In the interest of fostering an open and welcoming environment, we as contributo
 
 Examples of behavior that contributes to creating a positive environment include:
 
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
 
 Examples of unacceptable behavior by participants include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
 
 ## Our Responsibilities
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "4.0.0-beta.7"
+version = "4.0.0-beta.17"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
 keywords = ["actix", "http", "web", "framework", "async"]
@@ -11,19 +11,21 @@ categories = [
     "web-programming::websocket"
 ]
 homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web"
+repository = "https://github.com/actix/actix-web.git"
 license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
 # features that docs.rs will build with
-features = ["openssl", "rustls", "compress", "cookies", "secure-cookies"]
+features = ["openssl", "rustls", "compress-brotli", "compress-gzip", "compress-zstd", "cookies", "secure-cookies"]
+rustdoc-args = ["--cfg", "docsrs"]
 
 [lib]
 name = "actix_web"
 path = "src/lib.rs"
 
 [workspace]
+resolver = "2"
 members = [
     ".",
     "awc",
@@ -34,15 +36,18 @@ members = [
     "actix-web-codegen",
     "actix-http-test",
     "actix-test",
+    "actix-router",
 ]
-# enable when MSRV is 1.51+
-# resolver = "2"
 
 [features]
-default = ["compress", "cookies"]
+default = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
 
-# content-encoding support
-compress = ["actix-http/compress"]
+# Brotli algorithm content-encoding support
+compress-brotli = ["actix-http/compress-brotli", "__compress"]
+# Gzip and deflate algorithms content-encoding support
+compress-gzip = ["actix-http/compress-gzip", "__compress"]
+# Zstd algorithm content-encoding support
+compress-zstd = ["actix-http/compress-zstd", "__compress"]
 
 # support for cookies
 cookies = ["cookie"]
@@ -56,57 +61,69 @@ openssl = ["actix-http/openssl", "actix-tls/accept", "actix-tls/openssl"]
 # rustls
 rustls = ["actix-http/rustls", "actix-tls/accept", "actix-tls/rustls"]
 
+# Internal (PRIVATE!) features used to aid testing and checking feature status.
+# Don't rely on these whatsoever. They may disappear at anytime.
+__compress = []
+
+# io-uring feature only avaiable for Linux OSes.
+experimental-io-uring = ["actix-server/io-uring"]
+
 [dependencies]
-actix-codec = "0.4.0"
-actix-macros = "0.2.1"
-actix-router = "0.2.7"
-actix-rt = "2.2"
-actix-server = "2.0.0-beta.3"
+actix-codec = "0.4.1"
+actix-macros = "0.2.3"
+actix-rt = "2.3"
+actix-server = "2.0.0-rc.2"
 actix-service = "2.0.0"
 actix-utils = "3.0.0"
-actix-tls = { version = "3.0.0-beta.5", default-features = false, optional = true }
+actix-tls = { version = "3.0.0", default-features = false, optional = true }
 
-actix-web-codegen = "0.5.0-beta.2"
-actix-http = "3.0.0-beta.7"
+actix-http = "3.0.0-beta.17"
+actix-router = "0.5.0-beta.3"
+actix-web-codegen = "0.5.0-beta.6"
 
 ahash = "0.7"
 bytes = "1"
+cfg-if = "1"
 cookie = { version = "0.15", features = ["percent-encode"], optional = true }
 derive_more = "0.99.5"
-either = "1.5.3"
 encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
-itoa = "0.4"
+itoa = "1"
 language-tags = "0.3"
 once_cell = "1.5"
 log = "0.4"
 mime = "0.3"
 paste = "1"
-pin-project = "1.0.0"
+pin-project-lite = "0.2.7"
 regex = "1.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.7"
-smallvec = "1.6"
+smallvec = "1.6.1"
 socket2 = "0.4.0"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
+time = { version = "0.3", default-features = false, features = ["formatting"] }
 url = "2.1"
 
 [dev-dependencies]
-actix-test = { version = "0.1.0-beta.2", features = ["openssl", "rustls"] }
-awc = { version = "3.0.0-beta.6", features = ["openssl"] }
+actix-test = { version = "0.1.0-beta.10", features = ["openssl", "rustls"] }
+awc = { version = "3.0.0-beta.16", features = ["openssl"] }
 
 brotli2 = "0.3.2"
-criterion = "0.3"
-env_logger = "0.8"
+criterion = { version = "0.3", features = ["html_reports"] }
+env_logger = "0.9"
 flate2 = "1.0.13"
-zstd = "0.7"
+futures-util = { version = "0.3.7", default-features = false, features = ["std"] }
 rand = "0.8"
 rcgen = "0.8"
-serde_derive = "1.0"
+rustls-pemfile = "0.2"
 tls-openssl = { package = "openssl", version = "0.10.9" }
-tls-rustls = { package = "rustls", version = "0.19.0" }
+tls-rustls = { package = "rustls", version = "0.20.0" }
+zstd = "0.9"
+
+[profile.dev]
+# Disabling debug info speeds up builds a bunch and we don't rely on it for debugging that much.
+debug = 0
 
 [profile.release]
 lto = true
@@ -118,23 +135,33 @@ actix-files = { path = "actix-files" }
 actix-http = { path = "actix-http" }
 actix-http-test = { path = "actix-http-test" }
 actix-multipart = { path = "actix-multipart" }
+actix-router = { path = "actix-router" }
 actix-test = { path = "actix-test" }
 actix-web = { path = "." }
 actix-web-actors = { path = "actix-web-actors" }
 actix-web-codegen = { path = "actix-web-codegen" }
 awc = { path = "awc" }
 
+# uncomment for quick testing against local actix-net repo
+# actix-service = { path = "../actix-net/actix-service" }
+# actix-macros = { path = "../actix-net/actix-macros" }
+# actix-rt = { path = "../actix-net/actix-rt" }
+# actix-codec = { path = "../actix-net/actix-codec" }
+# actix-utils = { path = "../actix-net/actix-utils" }
+# actix-tls = { path = "../actix-net/actix-tls" }
+# actix-server = { path = "../actix-net/actix-server" }
+
 [[test]]
 name = "test_server"
-required-features = ["compress", "cookies"]
+required-features = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
 
 [[example]]
 name = "basic"
-required-features = ["compress"]
+required-features = ["compress-gzip"]
 
 [[example]]
 name = "uds"
-required-features = ["compress"]
+required-features = ["compress-gzip"]
 
 [[example]]
 name = "on_connect"

MIGRATION.md

@@ -1,42 +1,57 @@
 ## Unreleased
 
-* The default `NormalizePath` behavior now strips trailing slashes by default. This was
+- The default `NormalizePath` behavior now strips trailing slashes by default. This was
   previously documented to be the case in v3 but the behavior now matches. The effect is that
   routes defined with trailing slashes will become inaccessible when
-  using `NormalizePath::default()`.
+  using `NormalizePath::default()`. As such, calling `NormalizePath::default()` will log a warning.
+  It is advised that the `new` method be used instead.
   
-  Before: `#[get("/test/")`  
-  After: `#[get("/test")`  
+  Before: `#[get("/test/")]`  
+  After:  `#[get("/test")]`  
 
   Alternatively, explicitly require trailing slashes: `NormalizePath::new(TrailingSlash::Always)`.
 
+- The `type Config` of `FromRequest` was removed.
+
+- Feature flag `compress` has been split into its supported algorithm (brotli, gzip, zstd).
+  By default all compression algorithms are enabled.
+  To select algorithm you want to include with `middleware::Compress` use following flags:
+  - `compress-brotli`
+  - `compress-gzip`
+  - `compress-zstd`
+  If you have set in your `Cargo.toml` dedicated `actix-web` features and you still want
+  to have compression enabled. Please change features selection like bellow:
+
+  Before: `"compress"`
+  After: `"compress-brotli", "compress-gzip", "compress-zstd"`
+
 
 ## 3.0.0
 
-* The return type for `ServiceRequest::app_data::<T>()` was changed from returning a `Data<T>` to
+- The return type for `ServiceRequest::app_data::<T>()` was changed from returning a `Data<T>` to
   simply a `T`. To access a `Data<T>` use `ServiceRequest::app_data::<Data<T>>()`.
 
-* Cookie handling has been offloaded to the `cookie` crate:
+- Cookie handling has been offloaded to the `cookie` crate:
   * `USERINFO_ENCODE_SET` is no longer exposed. Percent-encoding is still supported; check docs.
   * Some types now require lifetime parameters.
 
-* The time crate was updated to `v0.2`, a major breaking change to the time crate, which affects
+- The time crate was updated to `v0.2`, a major breaking change to the time crate, which affects
   any `actix-web` method previously expecting a time v0.1 input.
 
-* Setting a cookie's SameSite property, explicitly, to `SameSite::None` will now
+- 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 
+- 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.
+- 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
+- `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
+- 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
@@ -56,35 +71,35 @@
   }
   ```
 
-* `middleware::NormalizePath` can now also be configured to trim trailing slashes instead of always keeping one.
+- `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::new(TrailingSlash::MergeOnly))`.
 
-* `HttpServer::maxconn` is renamed to the more expressive `HttpServer::max_connections`.
+- `HttpServer::maxconn` is renamed to the more expressive `HttpServer::max_connections`.
 
-* `HttpServer::maxconnrate` is renamed to the more expressive `HttpServer::max_connection_rate`.
+- `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
+- `HttpServer::start()` renamed to `HttpServer::run()`. It also possible to
   `.await` on `run` method result, in that case it awaits server exit.
 
-* `App::register_data()` renamed to `App::app_data()` and accepts any type `T: 'static`.
+- `App::register_data()` renamed to `App::app_data()` and accepts any type `T: 'static`.
   Stored data is available via `HttpRequest::app_data()` method at runtime.
 
-* Extractor configuration must be registered with `App::app_data()` instead of `App::data()`
+- Extractor configuration must be registered with `App::app_data()` instead of `App::data()`
 
-* Sync handlers has been removed. `.to_async()` method has been renamed to `.to()`
+- Sync handlers has been removed. `.to_async()` method has been renamed to `.to()`
   replace `fn` with `async fn` to convert sync handler to async
 
-* `actix_http_test::TestServer` moved to `actix_web::test` module. To start
+- `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
+- `ResponseError` trait has been reafctored. `ResponseError::error_response()` renders
   http response.
 
-* Feature `rust-tls` renamed to `rustls`
+- Feature `rust-tls` renamed to `rustls`
 
   instead of
 
@@ -98,7 +113,7 @@
     actix-web = { version = "2.0.0", features = ["rustls"] }
     ```
 
-* Feature `ssl` renamed to `openssl`
+- Feature `ssl` renamed to `openssl`
 
   instead of
 
@@ -111,11 +126,11 @@
     ```rust
     actix-web = { version = "2.0.0", features = ["openssl"] }
     ```
-* `Cors` builder now requires that you call `.finish()` to construct the middleware
+- `Cors` builder now requires that you call `.finish()` to construct the middleware
 
 ## 1.0.1
 
-* Cors middleware has been moved to `actix-cors` crate
+- Cors middleware has been moved to `actix-cors` crate
 
   instead of
 
@@ -129,7 +144,7 @@
   use actix_cors::Cors;
   ```
 
-* Identity middleware has been moved to `actix-identity` crate
+- Identity middleware has been moved to `actix-identity` crate
 
   instead of
 
@@ -146,7 +161,7 @@
 
 ## 1.0.0
 
-* Extractor configuration. In version 1.0 this is handled with the new `Data` mechanism for both setting and retrieving the configuration
+- Extractor configuration. In version 1.0 this is handled with the new `Data` mechanism for both setting and retrieving the configuration
 
   instead of
 
@@ -204,7 +219,7 @@
   )
   ```
 
-* Resource registration. 1.0 version uses generalized resource
+- Resource registration. 1.0 version uses generalized resource
   registration via `.service()` method.
 
   instead of
@@ -224,7 +239,7 @@
             .route(web::post().to(post_handler))
   ```
 
-* Scope registration.
+- Scope registration.
 
   instead of
 
@@ -248,7 +263,7 @@
       );
   ```
 
-* `.with()`, `.with_async()` registration methods have been renamed to `.to()` and `.to_async()`.
+- `.with()`, `.with_async()` registration methods have been renamed to `.to()` and `.to_async()`.
 
   instead of
 
@@ -262,7 +277,7 @@
     App.new().service(web::resource("/welcome").to(welcome))
   ```
 
-* Passing arguments to handler with extractors, multiple arguments are allowed
+- Passing arguments to handler with extractors, multiple arguments are allowed
 
   instead of
 
@@ -280,7 +295,7 @@
   }
   ```
 
-* `.f()`, `.a()` and `.h()` handler registration methods have been removed.
+- `.f()`, `.a()` and `.h()` handler registration methods have been removed.
   Use `.to()` for handlers and `.to_async()` for async handlers. Handler function
   must use extractors.
 
@@ -296,7 +311,7 @@
     App.new().service(web::resource("/welcome").to(welcome))
   ```
 
-* `HttpRequest` does not provide access to request's payload stream.
+- `HttpRequest` does not provide access to request's payload stream.
 
   instead of
 
@@ -326,7 +341,7 @@
   }
   ```
 
-* `State` is now `Data`.  You register Data during the App initialization process
+- `State` is now `Data`.  You register Data during the App initialization process
   and then access it from handlers either using a Data extractor or using
   HttpRequest's api.
 
@@ -362,7 +377,7 @@
   ```
 
 
-* AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
+- AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
 
   instead of
 
@@ -378,7 +393,7 @@
   .. simply omit AsyncResponder and the corresponding responder() finish method
 
 
-* Middleware
+- Middleware
 
   instead of
 
@@ -395,7 +410,7 @@
            .route("/index.html", web::get().to(index));
   ```
 
-* `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
+- `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
   method have been removed. Use `Bytes`, `String`, `Form`, `Json`, `Multipart` extractors instead.
 
   instead of
@@ -417,9 +432,9 @@
   }
   ```
 
-* `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
+- `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
 
-* StaticFiles and NamedFile have been moved to a separate crate.
+- StaticFiles and NamedFile have been moved to a separate crate.
 
   instead of `use actix_web::fs::StaticFile`
 
@@ -429,20 +444,20 @@
 
   use `use actix_files::NamedFile`
 
-* Multipart has been moved to a separate crate.
+- Multipart has been moved to a separate crate.
 
   instead of `use actix_web::multipart::Multipart`
 
   use `use actix_multipart::Multipart`
 
-* Response compression is not enabled by default.
+- Response compression is not enabled by default.
   To enable, use `Compress` middleware, `App::new().wrap(Compress::default())`.
 
-* Session middleware moved to actix-session crate
+- Session middleware moved to actix-session crate
 
-* Actors support have been moved to `actix-web-actors` crate
+- Actors support have been moved to `actix-web-actors` crate
 
-* Custom Error
+- Custom Error
 
   Instead of error_response method alone, ResponseError now provides two methods: error_response and render_response respectively. Where, error_response creates the error response and render_response returns the error response to the caller. 
 
@@ -456,7 +471,7 @@
 
 ## 0.7.15
 
-* The `' '` character is not percent decoded anymore before matching routes. If you need to use it in
+- The `' '` character is not percent decoded anymore before matching routes. If you need to use it in
   your routes, you should use `%20`.
 
   instead of
@@ -481,18 +496,18 @@
     }
     ```
 
-* If you used `AsyncResult::async` you need to replace it with `AsyncResult::future`
+- If you used `AsyncResult::async` you need to replace it with `AsyncResult::future`
 
 
 ## 0.7.4
 
-* `Route::with_config()`/`Route::with_async_config()` always passes configuration objects as tuple
+- `Route::with_config()`/`Route::with_async_config()` always passes configuration objects as tuple
   even for handler with one parameter.
 
 
 ## 0.7
 
-* `HttpRequest` does not implement `Stream` anymore. If you need to read request payload
+- `HttpRequest` does not implement `Stream` anymore. If you need to read request payload
   use `HttpMessage::payload()` method.
 
   instead of
@@ -518,10 +533,10 @@
     }
     ```
 
-* [Middleware](https://actix.rs/actix-web/actix_web/middleware/trait.Middleware.html)
+- [Middleware](https://actix.rs/actix-web/actix_web/middleware/trait.Middleware.html)
   trait uses `&HttpRequest` instead of `&mut HttpRequest`.
 
-* Removed `Route::with2()` and `Route::with3()` use tuple of extractors instead.
+- Removed `Route::with2()` and `Route::with3()` use tuple of extractors instead.
 
     instead of
 
@@ -535,17 +550,17 @@
     fn index((query, json): (Query<..>, Json<MyStruct)) -> impl Responder {}
     ```
 
-* `Handler::handle()` uses `&self` instead of `&mut self`
+- `Handler::handle()` uses `&self` instead of `&mut self`
 
-* `Handler::handle()` accepts reference to `HttpRequest<_>` instead of value
+- `Handler::handle()` accepts reference to `HttpRequest<_>` instead of value
 
-* Removed deprecated `HttpServer::threads()`, use
+- Removed deprecated `HttpServer::threads()`, use
   [HttpServer::workers()](https://actix.rs/actix-web/actix_web/server/struct.HttpServer.html#method.workers) instead.
 
-* Renamed `client::ClientConnectorError::Connector` to
+- Renamed `client::ClientConnectorError::Connector` to
   `client::ClientConnectorError::Resolver`
 
-* `Route::with()` does not return `ExtractorConfig`, to configure
+- `Route::with()` does not return `ExtractorConfig`, to configure
   extractor use `Route::with_config()`
 
     instead of
@@ -574,26 +589,26 @@
     }
     ```
 
-* `Route::with_async()` does not return `ExtractorConfig`, to configure
+- `Route::with_async()` does not return `ExtractorConfig`, to configure
   extractor use `Route::with_async_config()`
 
 
 ## 0.6
 
-* `Path<T>` extractor return `ErrorNotFound` on failure instead of `ErrorBadRequest`
+- `Path<T>` extractor return `ErrorNotFound` on failure instead of `ErrorBadRequest`
 
-* `ws::Message::Close` now includes optional close reason.
+- `ws::Message::Close` now includes optional close reason.
   `ws::CloseCode::Status` and `ws::CloseCode::Empty` have been removed.
 
-* `HttpServer::threads()` renamed to `HttpServer::workers()`.
+- `HttpServer::threads()` renamed to `HttpServer::workers()`.
 
-* `HttpServer::start_ssl()` and `HttpServer::start_tls()` deprecated.
+- `HttpServer::start_ssl()` and `HttpServer::start_tls()` deprecated.
   Use `HttpServer::bind_ssl()` and `HttpServer::bind_tls()` instead.
 
-* `HttpRequest::extensions()` returns read only reference to the request's Extension
+- `HttpRequest::extensions()` returns read only reference to the request's Extension
   `HttpRequest::extensions_mut()` returns mutable reference.
 
-* Instead of
+- Instead of
 
    `use actix_web::middleware::{
         CookieSessionBackend, CookieSessionError, RequestSession,
@@ -604,15 +619,15 @@
    `use actix_web::middleware::session{CookieSessionBackend, CookieSessionError,
         RequestSession, Session, SessionBackend, SessionImpl, SessionStorage};`
 
-* `FromRequest::from_request()` accepts mutable reference to a request
+- `FromRequest::from_request()` accepts mutable reference to a request
 
-* `FromRequest::Result` has to implement `Into<Reply<Self>>`
+- `FromRequest::Result` has to implement `Into<Reply<Self>>`
 
-* [`Responder::respond_to()`](
+- [`Responder::respond_to()`](
   https://actix.rs/actix-web/actix_web/trait.Responder.html#tymethod.respond_to)
   is generic over `S`
 
-*  Use `Query` extractor instead of HttpRequest::query()`.
+-  Use `Query` extractor instead of HttpRequest::query()`.
 
    ```rust
    fn index(q: Query<HashMap<String, String>>) -> Result<..> {
@@ -626,37 +641,37 @@
    let q = Query::<HashMap<String, String>>::extract(req);
    ```
 
-* Websocket operations are implemented as `WsWriter` trait.
+- Websocket operations are implemented as `WsWriter` trait.
   you need to use `use actix_web::ws::WsWriter`
 
 
 ## 0.5
 
-* `HttpResponseBuilder::body()`, `.finish()`, `.json()`
+- `HttpResponseBuilder::body()`, `.finish()`, `.json()`
    methods return `HttpResponse` instead of `Result<HttpResponse>`
 
-* `actix_web::Method`, `actix_web::StatusCode`, `actix_web::Version`
+- `actix_web::Method`, `actix_web::StatusCode`, `actix_web::Version`
    moved to `actix_web::http` module
 
-* `actix_web::header` moved to `actix_web::http::header`
+- `actix_web::header` moved to `actix_web::http::header`
 
-* `NormalizePath` moved to `actix_web::http` module
+- `NormalizePath` moved to `actix_web::http` module
 
-* `HttpServer` moved to `actix_web::server`, added new `actix_web::server::new()` function,
+- `HttpServer` moved to `actix_web::server`, added new `actix_web::server::new()` function,
   shortcut for `actix_web::server::HttpServer::new()`
 
-* `DefaultHeaders` middleware does not use separate builder, all builder methods moved to type itself
+- `DefaultHeaders` middleware does not use separate builder, all builder methods moved to type itself
 
-* `StaticFiles::new()`'s show_index parameter removed, use `show_files_listing()` method instead.
+- `StaticFiles::new()`'s show_index parameter removed, use `show_files_listing()` method instead.
 
-* `CookieSessionBackendBuilder` removed, all methods moved to `CookieSessionBackend` type
+- `CookieSessionBackendBuilder` removed, all methods moved to `CookieSessionBackend` type
 
-* `actix_web::httpcodes` module is deprecated, `HttpResponse::Ok()`, `HttpResponse::Found()` and other `HttpResponse::XXX()`
+- `actix_web::httpcodes` module is deprecated, `HttpResponse::Ok()`, `HttpResponse::Found()` and other `HttpResponse::XXX()`
    functions should be used instead
 
-* `ClientRequestBuilder::body()` returns `Result<_, actix_web::Error>`
+- `ClientRequestBuilder::body()` returns `Result<_, actix_web::Error>`
   instead of `Result<_, http::Error>`
 
-* `Application` renamed to a `App`
+- `Application` renamed to a `App`
 
-* `actix_web::Reply`, `actix_web::Resource` moved to `actix_web::dev`
+- `actix_web::Reply`, `actix_web::Resource` moved to `actix_web::dev`

README.md

@@ -6,10 +6,10 @@
   <p>
 
 [![crates.io](https://img.shields.io/crates/v/actix-web?label=latest)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.7)](https://docs.rs/actix-web/4.0.0-beta.7)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.17)](https://docs.rs/actix-web/4.0.0-beta.17)
+[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
-[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.7/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.7)
+[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.17/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.17)
 <br />
 [![build status](https://github.com/actix/actix-web/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-web/actions)
 [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) 
@@ -21,25 +21,25 @@
 
 ## Features
 
-* 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)
-* Powerful [request routing](https://actix.rs/docs/url-dispatch/)
-* Multipart streams
-* Static assets
-* SSL support using OpenSSL or Rustls
-* Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-* Includes an async [HTTP client](https://docs.rs/awc/)
-* Runs on stable Rust 1.46+
+- 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, zstd)
+- Powerful [request routing](https://actix.rs/docs/url-dispatch/)
+- Multipart streams
+- Static assets
+- SSL support using OpenSSL or Rustls
+- Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
+- Includes an async [HTTP client](https://docs.rs/awc/)
+- Runs on stable Rust 1.52+
 
 ## 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)
+- [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
 
@@ -71,18 +71,18 @@ async fn main() -> std::io::Result<()> {
 
 ### More examples
 
-* [Basic Setup](https://github.com/actix/examples/tree/master/basics/basics/)
-* [Application State](https://github.com/actix/examples/tree/master/basics/state/)
-* [JSON Handling](https://github.com/actix/examples/tree/master/json/json/)
-* [Multipart Streams](https://github.com/actix/examples/tree/master/forms/multipart/)
-* [Diesel Integration](https://github.com/actix/examples/tree/master/database_interactions/diesel/)
-* [r2d2 Integration](https://github.com/actix/examples/tree/master/database_interactions/r2d2/)
-* [Simple WebSocket](https://github.com/actix/examples/tree/master/websockets/websocket/)
-* [Tera Templates](https://github.com/actix/examples/tree/master/template_engines/tera/)
-* [Askama Templates](https://github.com/actix/examples/tree/master/template_engines/askama/)
-* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/security/rustls/)
-* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/security/openssl/)
-* [WebSocket Chat](https://github.com/actix/examples/tree/master/websockets/chat/)
+- [Basic Setup](https://github.com/actix/examples/tree/master/basics/basics/)
+- [Application State](https://github.com/actix/examples/tree/master/basics/state/)
+- [JSON Handling](https://github.com/actix/examples/tree/master/json/json/)
+- [Multipart Streams](https://github.com/actix/examples/tree/master/forms/multipart/)
+- [Diesel Integration](https://github.com/actix/examples/tree/master/database_interactions/diesel/)
+- [r2d2 Integration](https://github.com/actix/examples/tree/master/database_interactions/r2d2/)
+- [Simple WebSocket](https://github.com/actix/examples/tree/master/websockets/websocket/)
+- [Tera Templates](https://github.com/actix/examples/tree/master/template_engines/tera/)
+- [Askama Templates](https://github.com/actix/examples/tree/master/template_engines/askama/)
+- [HTTPS using Rustls](https://github.com/actix/examples/tree/master/security/rustls/)
+- [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/security/openssl/)
+- [WebSocket Chat](https://github.com/actix/examples/tree/master/websockets/chat/)
 
 You may consider checking out
 [this directory](https://github.com/actix/examples/tree/master/) for more examples.
@@ -96,9 +96,9 @@ One of the fastest web frameworks available according to the
 
 This project is licensed under either of
 
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
   [http://www.apache.org/licenses/LICENSE-2.0])
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or
   [http://opensource.org/licenses/MIT])
 
 at your option.

actix-files/CHANGES.md

@@ -3,11 +3,51 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.6.0-beta.12 - 2021-12-29
+* No significant changes since `0.6.0-beta.11`.
+
+
+## 0.6.0-beta.11 - 2021-12-27
+* No significant changes since `0.6.0-beta.10`.
+
+
+## 0.6.0-beta.10 - 2021-12-11
+- No significant changes since `0.6.0-beta.9`.
+
+
+## 0.6.0-beta.9 - 2021-11-22
+- Add crate feature `experimental-io-uring`, enabling async file I/O to be utilized. This feature is only available on Linux OSes with recent kernel versions. This feature is semver-exempt. [#2408]
+- Add `NamedFile::open_async`. [#2408]
+- Fix 304 Not Modified responses to omit the Content-Length header, as per the spec. [#2453]
+- The `Responder` impl for `NamedFile` now has a boxed future associated type. [#2408]
+- The `Service` impl for `NamedFileService` now has a boxed future associated type. [#2408]
+- Add `impl Clone` for `FilesService`. [#2408]
+
+[#2408]: https://github.com/actix/actix-web/pull/2408
+[#2453]: https://github.com/actix/actix-web/pull/2453
+
+
+## 0.6.0-beta.8 - 2021-10-20
+- Minimum supported Rust version (MSRV) is now 1.52.
+
+
+## 0.6.0-beta.7 - 2021-09-09
+- Minimum supported Rust version (MSRV) is now 1.51.
+
+
+## 0.6.0-beta.6 - 2021-06-26
+- Added `Files::path_filter()`. [#2274]
+- `Files::show_files_listing()` can now be used with `Files::index_file()` to show files listing as a fallback when the index file is not found. [#2228]
+
+[#2274]: https://github.com/actix/actix-web/pull/2274
+[#2228]: https://github.com/actix/actix-web/pull/2228
+
+
 ## 0.6.0-beta.5 - 2021-06-17
-* `NamedFile` now implements `ServiceFactory` and `HttpServiceFactory` making it much more useful in routing. For example, it can be used directly as a default service. [#2135]
-* For symbolic links, `Content-Disposition` header no longer shows the filename of the original file. [#2156]
-* `Files::redirect_to_slash_directory()` now works as expected when used with `Files::show_files_listing()`. [#2225]
-* `application/{javascript, json, wasm}` mime type now have `inline` disposition by default. [#2257]
+- `NamedFile` now implements `ServiceFactory` and `HttpServiceFactory` making it much more useful in routing. For example, it can be used directly as a default service. [#2135]
+- For symbolic links, `Content-Disposition` header no longer shows the filename of the original file. [#2156]
+- `Files::redirect_to_slash_directory()` now works as expected when used with `Files::show_files_listing()`. [#2225]
+- `application/{javascript, json, wasm}` mime type now have `inline` disposition by default. [#2257]
 
 [#2135]: https://github.com/actix/actix-web/pull/2135
 [#2156]: https://github.com/actix/actix-web/pull/2156
@@ -16,131 +56,130 @@
 
 
 ## 0.6.0-beta.4 - 2021-04-02
-* No notable changes.
-
-* Add support for `.guard` in `Files` to selectively filter `Files` services. [#2046]
+- Add support for `.guard` in `Files` to selectively filter `Files` services. [#2046]
 
 [#2046]: https://github.com/actix/actix-web/pull/2046
 
+
 ## 0.6.0-beta.3 - 2021-03-09
-* No notable changes.
+- No notable changes.
 
 
 ## 0.6.0-beta.2 - 2021-02-10
-* Fix If-Modified-Since and If-Unmodified-Since to not compare using sub-second timestamps. [#1887]
-* Replace `v_htmlescape` with `askama_escape`. [#1953]
+- Fix If-Modified-Since and If-Unmodified-Since to not compare using sub-second timestamps. [#1887]
+- Replace `v_htmlescape` with `askama_escape`. [#1953]
 
 [#1887]: https://github.com/actix/actix-web/pull/1887
 [#1953]: https://github.com/actix/actix-web/pull/1953
 
 
 ## 0.6.0-beta.1 - 2021-01-07
-* `HttpRange::parse` now has its own error type.
-* Update `bytes` to `1.0`. [#1813]
+- `HttpRange::parse` now has its own error type.
+- Update `bytes` to `1.0`. [#1813]
 
 [#1813]: https://github.com/actix/actix-web/pull/1813
 
 
 ## 0.5.0 - 2020-12-26
-* Optionally support hidden files/directories. [#1811]
+- Optionally support hidden files/directories. [#1811]
 
 [#1811]: https://github.com/actix/actix-web/pull/1811
 
 
 ## 0.4.1 - 2020-11-24
-* Clarify order of parameters in `Files::new` and improve docs.
+- Clarify order of parameters in `Files::new` and improve docs.
 
 
 ## 0.4.0 - 2020-10-06
-* Add `Files::prefer_utf8` option that adds UTF-8 charset on certain response types. [#1714]
+- Add `Files::prefer_utf8` option that adds UTF-8 charset on certain response types. [#1714]
 
 [#1714]: https://github.com/actix/actix-web/pull/1714
 
 
 ## 0.3.0 - 2020-09-11
-* No significant changes from 0.3.0-beta.1.
+- No significant changes from 0.3.0-beta.1.
 
 
 ## 0.3.0-beta.1 - 2020-07-15
-* Update `v_htmlescape` to 0.10
-* Update `actix-web` and `actix-http` dependencies to beta.1
+- 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]
+- 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
+- Use the same format for file URLs regardless of platforms
 
 
 ## 0.2.0 - 2019-12-20
-* Fix BodyEncoding trait import #1220
+- Fix BodyEncoding trait import #1220
 
 
 ## 0.2.0-alpha.1 - 2019-12-07
-* Migrate to `std::future`
+- Migrate to `std::future`
 
 
 ## 0.1.7 - 2019-11-06
-* Add an additional `filename*` param in the `Content-Disposition` header of
+- Add an additional `filename*` param in the `Content-Disposition` header of
   `actix_files::NamedFile` to be more compatible. (#1151)
 
 ## 0.1.6 - 2019-10-14
-* Add option to redirect to a slash-ended path `Files` #1132
+- Add option to redirect to a slash-ended path `Files` #1132
 
 
 ## 0.1.5 - 2019-10-08
-* Bump up `mime_guess` crate version to 2.0.1
-* Bump up `percent-encoding` crate version to 2.1
-* Allow user defined request guards for `Files` #1113
+- Bump up `mime_guess` crate version to 2.0.1
+- Bump up `percent-encoding` crate version to 2.1
+- Allow user defined request guards for `Files` #1113
 
 
 ## 0.1.4 - 2019-07-20
-* Allow to disable `Content-Disposition` header #686
+- Allow to disable `Content-Disposition` header #686
 
 
 ## 0.1.3 - 2019-06-28
-* Do not set `Content-Length` header, let actix-http set it #930
+- Do not set `Content-Length` header, let actix-http set it #930
 
 
 ## 0.1.2 - 2019-06-13
-* Content-Length is 0 for NamedFile HEAD request #914
-* Fix ring dependency from actix-web default features for #741
+- Content-Length is 0 for NamedFile HEAD request #914
+- Fix ring dependency from actix-web default features for #741
 
 
 ## 0.1.1 - 2019-06-01
-* Static files are incorrectly served as both chunked and with length #812
+- Static files are incorrectly served as both chunked and with length #812
 
 
 ## 0.1.0 - 2019-05-25
-* NamedFile last-modified check always fails due to nano-seconds in file modified date #820
+- NamedFile last-modified check always fails due to nano-seconds in file modified date #820
 
 
 ## 0.1.0-beta.4 - 2019-05-12
-* Update actix-web to beta.4
+- Update actix-web to beta.4
 
 
 ## 0.1.0-beta.1 - 2019-04-20
-* Update actix-web to beta.1
+- Update actix-web to beta.1
 
 
 ## 0.1.0-alpha.6 - 2019-04-14
-* Update actix-web to alpha6
+- Update actix-web to alpha6
 
 
 ## 0.1.0-alpha.4 - 2019-04-08
-* Update actix-web to alpha4
+- Update actix-web to alpha4
 
 
 ## 0.1.0-alpha.2 - 2019-04-02
-* Add default handler support
+- Add default handler support
 
 
 ## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl
+- Initial impl

actix-files/Cargo.toml

@@ -1,13 +1,15 @@
 [package]
 name = "actix-files"
-version = "0.6.0-beta.5"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+version = "0.6.0-beta.12"
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "fakeshadow <24548779@qq.com>",
+    "Rob Ede <robjtede@icloud.com>",
+]
 description = "Static file serving for Actix Web"
-readme = "README.md"
 keywords = ["actix", "http", "async", "futures"]
 homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-files/"
+repository = "https://github.com/actix/actix-web"
 categories = ["asynchronous", "web-programming::http-server"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
@@ -16,24 +18,30 @@ edition = "2018"
 name = "actix_files"
 path = "src/lib.rs"
 
+[features]
+experimental-io-uring = ["actix-web/experimental-io-uring", "tokio-uring"]
+
 [dependencies]
-actix-web = { version = "4.0.0-beta.7", default-features = false }
-actix-http = "3.0.0-beta.7"
-actix-service = "2.0.0"
-actix-utils = "3.0.0"
+actix-http = "3.0.0-beta.17"
+actix-service = "2"
+actix-utils = "3"
+actix-web = { version = "4.0.0-beta.17", default-features = false }
 
 askama_escape = "0.10"
 bitflags = "1"
 bytes = "1"
+derive_more = "0.99.5"
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
 http-range = "0.1.4"
-derive_more = "0.99.5"
 log = "0.4"
 mime = "0.3"
 mime_guess = "2.0.1"
 percent-encoding = "2.1"
+pin-project-lite = "0.2.7"
+
+tokio-uring = { version = "0.1", optional = true }
 
 [dev-dependencies]
 actix-rt = "2.2"
-actix-web = "4.0.0-beta.7"
-actix-test = "0.1.0-beta.2"
+actix-test = "0.1.0-beta.10"
+actix-web = "4.0.0-beta.17"

actix-files/README.md

@@ -3,17 +3,16 @@
 > Static file serving for Actix Web
 
 [![crates.io](https://img.shields.io/crates/v/actix-files?label=latest)](https://crates.io/crates/actix-files)
-[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.5)](https://docs.rs/actix-files/0.6.0-beta.5)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.12)](https://docs.rs/actix-files/0.6.0-beta.12)
+[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![License](https://img.shields.io/crates/l/actix-files.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.5/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.5)
+[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.12/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.12)
 [![Download](https://img.shields.io/crates/d/actix-files.svg)](https://crates.io/crates/actix-files)
-[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-files/)
 - [Example Project](https://github.com/actix/examples/tree/master/basics/static_index)
-- [Chat on Gitter](https://gitter.im/actix/actix-web)
-- Minimum supported Rust version: 1.46 or later
+- Minimum Supported Rust Version (MSRV): 1.52

actix-files/src/chunked.rs

@@ -1,98 +1,277 @@
 use std::{
     cmp, fmt,
-    fs::File,
     future::Future,
-    io::{self, Read, Seek},
+    io,
     pin::Pin,
     task::{Context, Poll},
 };
 
-use actix_web::{
-    error::{BlockingError, Error},
-    rt::task::{spawn_blocking, JoinHandle},
-};
-use bytes::Bytes;
+use actix_web::{error::Error, web::Bytes};
 use futures_core::{ready, Stream};
+use pin_project_lite::pin_project;
 
-#[doc(hidden)]
-/// A helper created from a `std::fs::File` which reads the file
-/// chunk-by-chunk on a `ThreadPool`.
-pub struct ChunkedReadFile {
-    size: u64,
-    offset: u64,
-    state: ChunkedReadFileState,
-    counter: u64,
-}
+use super::named::File;
 
-enum ChunkedReadFileState {
-    File(Option<File>),
-    Future(JoinHandle<Result<(File, Bytes), io::Error>>),
-}
-
-impl ChunkedReadFile {
-    pub(crate) fn new(size: u64, offset: u64, file: File) -> Self {
-        Self {
-            size,
-            offset,
-            state: ChunkedReadFileState::File(Some(file)),
-            counter: 0,
-        }
+pin_project! {
+    /// Adapter to read a `std::file::File` in chunks.
+    #[doc(hidden)]
+    pub struct ChunkedReadFile<F, Fut> {
+        size: u64,
+        offset: u64,
+        #[pin]
+        state: ChunkedReadFileState<Fut>,
+        counter: u64,
+        callback: F,
     }
 }
 
-impl fmt::Debug for ChunkedReadFile {
+#[cfg(not(feature = "experimental-io-uring"))]
+pin_project! {
+    #[project = ChunkedReadFileStateProj]
+    #[project_replace = ChunkedReadFileStateProjReplace]
+    enum ChunkedReadFileState<Fut> {
+        File { file: Option<File>, },
+        Future { #[pin] fut: Fut },
+    }
+}
+
+#[cfg(feature = "experimental-io-uring")]
+pin_project! {
+    #[project = ChunkedReadFileStateProj]
+    #[project_replace = ChunkedReadFileStateProjReplace]
+    enum ChunkedReadFileState<Fut> {
+        File { file: Option<(File, BytesMut)> },
+        Future { #[pin] fut: Fut },
+    }
+}
+
+impl<F, Fut> fmt::Debug for ChunkedReadFile<F, Fut> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("ChunkedReadFile")
     }
 }
 
-impl Stream for ChunkedReadFile {
+pub(crate) fn new_chunked_read(
+    size: u64,
+    offset: u64,
+    file: File,
+) -> impl Stream<Item = Result<Bytes, Error>> {
+    ChunkedReadFile {
+        size,
+        offset,
+        #[cfg(not(feature = "experimental-io-uring"))]
+        state: ChunkedReadFileState::File { file: Some(file) },
+        #[cfg(feature = "experimental-io-uring")]
+        state: ChunkedReadFileState::File {
+            file: Some((file, BytesMut::new())),
+        },
+        counter: 0,
+        callback: chunked_read_file_callback,
+    }
+}
+
+#[cfg(not(feature = "experimental-io-uring"))]
+async fn chunked_read_file_callback(
+    mut file: File,
+    offset: u64,
+    max_bytes: usize,
+) -> Result<(File, Bytes), Error> {
+    use io::{Read as _, Seek as _};
+
+    let res = actix_web::rt::task::spawn_blocking(move || {
+        let mut buf = Vec::with_capacity(max_bytes);
+
+        file.seek(io::SeekFrom::Start(offset))?;
+
+        let n_bytes = file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
+
+        if n_bytes == 0 {
+            Err(io::Error::from(io::ErrorKind::UnexpectedEof))
+        } else {
+            Ok((file, Bytes::from(buf)))
+        }
+    })
+    .await
+    .map_err(|_| actix_web::error::BlockingError)??;
+
+    Ok(res)
+}
+
+#[cfg(feature = "experimental-io-uring")]
+async fn chunked_read_file_callback(
+    file: File,
+    offset: u64,
+    max_bytes: usize,
+    mut bytes_mut: BytesMut,
+) -> io::Result<(File, Bytes, BytesMut)> {
+    bytes_mut.reserve(max_bytes);
+
+    let (res, mut bytes_mut) = file.read_at(bytes_mut, offset).await;
+    let n_bytes = res?;
+
+    if n_bytes == 0 {
+        return Err(io::ErrorKind::UnexpectedEof.into());
+    }
+
+    let bytes = bytes_mut.split_to(n_bytes).freeze();
+
+    Ok((file, bytes, bytes_mut))
+}
+
+#[cfg(feature = "experimental-io-uring")]
+impl<F, Fut> Stream for ChunkedReadFile<F, Fut>
+where
+    F: Fn(File, u64, usize, BytesMut) -> Fut,
+    Fut: Future<Output = io::Result<(File, Bytes, BytesMut)>>,
+{
     type Item = Result<Bytes, Error>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let this = self.as_mut().get_mut();
-        match this.state {
-            ChunkedReadFileState::File(ref mut file) => {
-                let size = this.size;
-                let offset = this.offset;
-                let counter = this.counter;
+        let mut this = self.as_mut().project();
+        match this.state.as_mut().project() {
+            ChunkedReadFileStateProj::File { file } => {
+                let size = *this.size;
+                let offset = *this.offset;
+                let counter = *this.counter;
 
                 if size == counter {
                     Poll::Ready(None)
                 } else {
-                    let mut file = file
+                    let max_bytes = cmp::min(size.saturating_sub(counter), 65_536) as usize;
+
+                    let (file, bytes_mut) = file
                         .take()
                         .expect("ChunkedReadFile polled after completion");
 
-                    let fut = spawn_blocking(move || {
-                        let max_bytes = cmp::min(size.saturating_sub(counter), 65_536) as usize;
+                    let fut = (this.callback)(file, offset, max_bytes, bytes_mut);
 
-                        let mut buf = Vec::with_capacity(max_bytes);
-                        file.seek(io::SeekFrom::Start(offset))?;
+                    this.state
+                        .project_replace(ChunkedReadFileState::Future { fut });
 
-                        let n_bytes =
-                            file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
-
-                        if n_bytes == 0 {
-                            return Err(io::ErrorKind::UnexpectedEof.into());
-                        }
-
-                        Ok((file, Bytes::from(buf)))
-                    });
-                    this.state = ChunkedReadFileState::Future(fut);
                     self.poll_next(cx)
                 }
             }
-            ChunkedReadFileState::Future(ref mut fut) => {
-                let (file, bytes) =
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
-                this.state = ChunkedReadFileState::File(Some(file));
+            ChunkedReadFileStateProj::Future { fut } => {
+                let (file, bytes, bytes_mut) = ready!(fut.poll(cx))?;
 
-                this.offset += bytes.len() as u64;
-                this.counter += bytes.len() as u64;
+                this.state.project_replace(ChunkedReadFileState::File {
+                    file: Some((file, bytes_mut)),
+                });
+
+                *this.offset += bytes.len() as u64;
+                *this.counter += bytes.len() as u64;
 
                 Poll::Ready(Some(Ok(bytes)))
             }
         }
     }
 }
+
+#[cfg(not(feature = "experimental-io-uring"))]
+impl<F, Fut> Stream for ChunkedReadFile<F, Fut>
+where
+    F: Fn(File, u64, usize) -> Fut,
+    Fut: Future<Output = Result<(File, Bytes), Error>>,
+{
+    type Item = Result<Bytes, Error>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut this = self.as_mut().project();
+        match this.state.as_mut().project() {
+            ChunkedReadFileStateProj::File { file } => {
+                let size = *this.size;
+                let offset = *this.offset;
+                let counter = *this.counter;
+
+                if size == counter {
+                    Poll::Ready(None)
+                } else {
+                    let max_bytes = cmp::min(size.saturating_sub(counter), 65_536) as usize;
+
+                    let file = file
+                        .take()
+                        .expect("ChunkedReadFile polled after completion");
+
+                    let fut = (this.callback)(file, offset, max_bytes);
+
+                    this.state
+                        .project_replace(ChunkedReadFileState::Future { fut });
+
+                    self.poll_next(cx)
+                }
+            }
+            ChunkedReadFileStateProj::Future { fut } => {
+                let (file, bytes) = ready!(fut.poll(cx))?;
+
+                this.state
+                    .project_replace(ChunkedReadFileState::File { file: Some(file) });
+
+                *this.offset += bytes.len() as u64;
+                *this.counter += bytes.len() as u64;
+
+                Poll::Ready(Some(Ok(bytes)))
+            }
+        }
+    }
+}
+
+#[cfg(feature = "experimental-io-uring")]
+use bytes_mut::BytesMut;
+
+// TODO: remove new type and use bytes::BytesMut directly
+#[doc(hidden)]
+#[cfg(feature = "experimental-io-uring")]
+mod bytes_mut {
+    use std::ops::{Deref, DerefMut};
+
+    use tokio_uring::buf::{IoBuf, IoBufMut};
+
+    #[derive(Debug)]
+    pub struct BytesMut(bytes::BytesMut);
+
+    impl BytesMut {
+        pub(super) fn new() -> Self {
+            Self(bytes::BytesMut::new())
+        }
+    }
+
+    impl Deref for BytesMut {
+        type Target = bytes::BytesMut;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl DerefMut for BytesMut {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    unsafe impl IoBuf for BytesMut {
+        fn stable_ptr(&self) -> *const u8 {
+            self.0.as_ptr()
+        }
+
+        fn bytes_init(&self) -> usize {
+            self.0.len()
+        }
+
+        fn bytes_total(&self) -> usize {
+            self.0.capacity()
+        }
+    }
+
+    unsafe impl IoBufMut for BytesMut {
+        fn stable_mut_ptr(&mut self) -> *mut u8 {
+            self.0.as_mut_ptr()
+        }
+
+        unsafe fn set_init(&mut self, init_len: usize) {
+            if self.len() < init_len {
+                self.0.set_len(init_len);
+            }
+        }
+    }
+}

actix-files/src/error.rs

@@ -21,6 +21,7 @@ impl ResponseError for FilesError {
     }
 }
 
+#[allow(clippy::enum_variant_names)]
 #[derive(Display, Debug, PartialEq)]
 pub enum UriSegmentError {
     /// The segment started with the wrapped invalid character.

actix-files/src/files.rs

@@ -1,9 +1,16 @@
-use std::{cell::RefCell, fmt, io, path::PathBuf, rc::Rc};
+use std::{
+    cell::RefCell,
+    fmt, io,
+    path::{Path, PathBuf},
+    rc::Rc,
+};
 
 use actix_service::{boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt};
-use actix_utils::future::ok;
 use actix_web::{
-    dev::{AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse},
+    dev::{
+        AppService, HttpServiceFactory, RequestHead, ResourceDef, ServiceRequest,
+        ServiceResponse,
+    },
     error::Error,
     guard::Guard,
     http::header::DispositionType,
@@ -12,8 +19,9 @@ use actix_web::{
 use futures_core::future::LocalBoxFuture;
 
 use crate::{
-    directory_listing, named, Directory, DirectoryRenderer, FilesService, HttpNewService,
-    MimeOverride,
+    directory_listing, named,
+    service::{FilesService, FilesServiceInner},
+    Directory, DirectoryRenderer, HttpNewService, MimeOverride, PathFilter,
 };
 
 /// Static files handling service.
@@ -36,6 +44,7 @@ pub struct Files {
     default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
     renderer: Rc<DirectoryRenderer>,
     mime_override: Option<Rc<MimeOverride>>,
+    path_filter: Option<Rc<PathFilter>>,
     file_flags: named::Flags,
     use_guards: Option<Rc<dyn Guard>>,
     guards: Vec<Rc<dyn Guard>>,
@@ -60,6 +69,7 @@ impl Clone for Files {
             file_flags: self.file_flags,
             path: self.path.clone(),
             mime_override: self.mime_override.clone(),
+            path_filter: self.path_filter.clone(),
             use_guards: self.use_guards.clone(),
             guards: self.guards.clone(),
             hidden_files: self.hidden_files,
@@ -96,7 +106,7 @@ impl Files {
         };
 
         Files {
-            path: mount_path.to_owned(),
+            path: mount_path.trim_end_matches('/').to_owned(),
             directory: dir,
             index: None,
             show_index: false,
@@ -104,6 +114,7 @@ impl Files {
             default: Rc::new(RefCell::new(None)),
             renderer: Rc::new(directory_listing),
             mime_override: None,
+            path_filter: None,
             file_flags: named::Flags::default(),
             use_guards: None,
             guards: Vec::new(),
@@ -114,6 +125,9 @@ impl Files {
     /// Show files listing for directories.
     ///
     /// By default show files listing is disabled.
+    ///
+    /// When used with [`Files::index_file()`], files listing is shown as a fallback
+    /// when the index file is not found.
     pub fn show_files_listing(mut self) -> Self {
         self.show_index = true;
         self
@@ -146,10 +160,45 @@ impl Files {
         self
     }
 
+    /// Sets path filtering closure.
+    ///
+    /// The path provided to the closure is relative to `serve_from` path.
+    /// You can safely join this path with the `serve_from` path to get the real path.
+    /// However, the real path may not exist since the filter is called before checking path existence.
+    ///
+    /// When a path doesn't pass the filter, [`Files::default_handler`] is called if set, otherwise,
+    /// `404 Not Found` is returned.
+    ///
+    /// # Examples
+    /// ```
+    /// use std::path::Path;
+    /// use actix_files::Files;
+    ///
+    /// // prevent searching subdirectories and following symlinks
+    /// let files_service = Files::new("/", "./static").path_filter(|path, _| {
+    ///     path.components().count() == 1
+    ///         && Path::new("./static")
+    ///             .join(path)
+    ///             .symlink_metadata()
+    ///             .map(|m| !m.file_type().is_symlink())
+    ///             .unwrap_or(false)
+    /// });
+    /// ```
+    pub fn path_filter<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&Path, &RequestHead) -> bool + 'static,
+    {
+        self.path_filter = Some(Rc::new(f));
+        self
+    }
+
     /// Set index file
     ///
-    /// Shows specific index file for directory "/" instead of
+    /// Shows specific index file for directories instead of
     /// showing files listing.
+    ///
+    /// If the index file is not found, files listing is shown as a fallback if
+    /// [`Files::show_files_listing()`] is set.
     pub fn index_file<T: Into<String>>(mut self, index: T) -> Self {
         self.index = Some(index.into());
         self
@@ -213,9 +262,9 @@ impl Files {
         self
     }
 
+    /// See [`Files::method_guard`].
     #[doc(hidden)]
     #[deprecated(since = "0.6.0", note = "Renamed to `method_guard`.")]
-    /// See [`Files::method_guard`].
     pub fn use_guards<G: Guard + 'static>(self, guard: G) -> Self {
         self.method_guard(guard)
     }
@@ -234,11 +283,17 @@ impl Files {
     /// Setting a fallback static file handler:
     /// ```
     /// use actix_files::{Files, NamedFile};
+    /// use actix_web::dev::{ServiceRequest, ServiceResponse, fn_service};
     ///
     /// # fn run() -> Result<(), actix_web::Error> {
     /// let files = Files::new("/", "./static")
     ///     .index_file("index.html")
-    ///     .default_handler(NamedFile::open("./static/404.html")?);
+    ///     .default_handler(fn_service(|req: ServiceRequest| async {
+    ///         let (req, _) = req.into_parts();
+    ///         let file = NamedFile::open_async("./static/404.html").await?;
+    ///         let res = file.into_response(&req);
+    ///         Ok(ServiceResponse::new(req, res))
+    ///     }));
     /// # Ok(())
     /// # }
     /// ```
@@ -304,7 +359,7 @@ impl ServiceFactory<ServiceRequest> for Files {
     type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        let mut srv = FilesService {
+        let mut inner = FilesServiceInner {
             directory: self.directory.clone(),
             index: self.index.clone(),
             show_index: self.show_index,
@@ -312,6 +367,7 @@ impl ServiceFactory<ServiceRequest> for Files {
             default: None,
             renderer: self.renderer.clone(),
             mime_override: self.mime_override.clone(),
+            path_filter: self.path_filter.clone(),
             file_flags: self.file_flags,
             guards: self.use_guards.clone(),
             hidden_files: self.hidden_files,
@@ -322,14 +378,14 @@ impl ServiceFactory<ServiceRequest> for Files {
             Box::pin(async {
                 match fut.await {
                     Ok(default) => {
-                        srv.default = Some(default);
-                        Ok(srv)
+                        inner.default = Some(default);
+                        Ok(FilesService(Rc::new(inner)))
                     }
                     Err(_) => Err(()),
                 }
             })
         } else {
-            Box::pin(ok(srv))
+            Box::pin(async move { Ok(FilesService(Rc::new(inner))) })
         }
     }
 }

actix-files/src/lib.rs

@@ -11,16 +11,17 @@
 //!     .service(Files::new("/static", ".").prefer_utf8(true));
 //! ```
 
-#![deny(rust_2018_idioms)]
-#![warn(missing_docs, missing_debug_implementations)]
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![warn(future_incompatible, missing_docs, missing_debug_implementations)]
 
 use actix_service::boxed::{BoxService, BoxServiceFactory};
 use actix_web::{
-    dev::{ServiceRequest, ServiceResponse},
+    dev::{RequestHead, ServiceRequest, ServiceResponse},
     error::Error,
     http::header::DispositionType,
 };
 use mime_guess::from_ext;
+use std::path::Path;
 
 mod chunked;
 mod directory;
@@ -32,12 +33,12 @@ mod path_buf;
 mod range;
 mod service;
 
-pub use crate::chunked::ChunkedReadFile;
-pub use crate::directory::Directory;
-pub use crate::files::Files;
-pub use crate::named::NamedFile;
-pub use crate::range::HttpRange;
-pub use crate::service::FilesService;
+pub use self::chunked::ChunkedReadFile;
+pub use self::directory::Directory;
+pub use self::files::Files;
+pub use self::named::NamedFile;
+pub use self::range::HttpRange;
+pub use self::service::FilesService;
 
 use self::directory::{directory_listing, DirectoryRenderer};
 use self::error::FilesError;
@@ -56,16 +57,17 @@ pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
 
 type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;
 
+type PathFilter = dyn Fn(&Path, &RequestHead) -> bool;
+
 #[cfg(test)]
 mod tests {
     use std::{
-        fs::{self, File},
+        fs::{self},
         ops::Add,
         time::{Duration, SystemTime},
     };
 
     use actix_service::ServiceFactory;
-    use actix_utils::future::ok;
     use actix_web::{
         guard,
         http::{
@@ -79,8 +81,9 @@ mod tests {
     };
 
     use super::*;
+    use crate::named::File;
 
-    #[actix_rt::test]
+    #[actix_web::test]
     async fn test_file_extension_to_mime() {
         let m = file_extension_to_mime("");
         assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
@@ -97,7 +100,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_if_modified_since_without_if_none_match() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
+        let file = NamedFile::open_async("Cargo.toml").await.unwrap();
         let since = header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
 
         let req = TestRequest::default()
@@ -109,7 +112,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_if_modified_since_without_if_none_match_same() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
+        let file = NamedFile::open_async("Cargo.toml").await.unwrap();
         let since = file.last_modified().unwrap();
 
         let req = TestRequest::default()
@@ -121,7 +124,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_if_modified_since_with_if_none_match() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
+        let file = NamedFile::open_async("Cargo.toml").await.unwrap();
         let since = header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
 
         let req = TestRequest::default()
@@ -134,7 +137,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_if_unmodified_since() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
+        let file = NamedFile::open_async("Cargo.toml").await.unwrap();
         let since = file.last_modified().unwrap();
 
         let req = TestRequest::default()
@@ -146,7 +149,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_if_unmodified_since_failed() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
+        let file = NamedFile::open_async("Cargo.toml").await.unwrap();
         let since = header::HttpDate::from(SystemTime::UNIX_EPOCH);
 
         let req = TestRequest::default()
@@ -158,8 +161,8 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_text() {
-        assert!(NamedFile::open("test--").is_err());
-        let mut file = NamedFile::open("Cargo.toml").unwrap();
+        assert!(NamedFile::open_async("test--").await.is_err());
+        let mut file = NamedFile::open_async("Cargo.toml").await.unwrap();
         {
             file.file();
             let _f: &File = &file;
@@ -182,8 +185,8 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_content_disposition() {
-        assert!(NamedFile::open("test--").is_err());
-        let mut file = NamedFile::open("Cargo.toml").unwrap();
+        assert!(NamedFile::open_async("test--").await.is_err());
+        let mut file = NamedFile::open_async("Cargo.toml").await.unwrap();
         {
             file.file();
             let _f: &File = &file;
@@ -199,7 +202,8 @@ mod tests {
             "inline; filename=\"Cargo.toml\""
         );
 
-        let file = NamedFile::open("Cargo.toml")
+        let file = NamedFile::open_async("Cargo.toml")
+            .await
             .unwrap()
             .disable_content_disposition();
         let req = TestRequest::default().to_http_request();
@@ -209,8 +213,19 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_non_ascii_file_name() {
-        let mut file =
-            NamedFile::from_file(File::open("Cargo.toml").unwrap(), "貨物.toml").unwrap();
+        let file = {
+            #[cfg(feature = "experimental-io-uring")]
+            {
+                crate::named::File::open("Cargo.toml").await.unwrap()
+            }
+
+            #[cfg(not(feature = "experimental-io-uring"))]
+            {
+                crate::named::File::open("Cargo.toml").unwrap()
+            }
+        };
+
+        let mut file = NamedFile::from_file(file, "貨物.toml").unwrap();
         {
             file.file();
             let _f: &File = &file;
@@ -233,7 +248,8 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_set_content_type() {
-        let mut file = NamedFile::open("Cargo.toml")
+        let mut file = NamedFile::open_async("Cargo.toml")
+            .await
             .unwrap()
             .set_content_type(mime::TEXT_XML);
         {
@@ -258,7 +274,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_image() {
-        let mut file = NamedFile::open("tests/test.png").unwrap();
+        let mut file = NamedFile::open_async("tests/test.png").await.unwrap();
         {
             file.file();
             let _f: &File = &file;
@@ -281,7 +297,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_javascript() {
-        let file = NamedFile::open("tests/test.js").unwrap();
+        let file = NamedFile::open_async("tests/test.js").await.unwrap();
 
         let req = TestRequest::default().to_http_request();
         let resp = file.respond_to(&req).await.unwrap();
@@ -301,7 +317,8 @@ mod tests {
             disposition: DispositionType::Attachment,
             parameters: vec![DispositionParam::Filename(String::from("test.png"))],
         };
-        let mut file = NamedFile::open("tests/test.png")
+        let mut file = NamedFile::open_async("tests/test.png")
+            .await
             .unwrap()
             .set_content_disposition(cd);
         {
@@ -326,7 +343,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_binary() {
-        let mut file = NamedFile::open("tests/test.binary").unwrap();
+        let mut file = NamedFile::open_async("tests/test.binary").await.unwrap();
         {
             file.file();
             let _f: &File = &file;
@@ -349,7 +366,8 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_status_code_text() {
-        let mut file = NamedFile::open("Cargo.toml")
+        let mut file = NamedFile::open_async("Cargo.toml")
+            .await
             .unwrap()
             .set_status_code(StatusCode::NOT_FOUND);
         {
@@ -565,7 +583,8 @@ mod tests {
     async fn test_named_file_content_encoding() {
         let srv = test::init_service(App::new().wrap(Compress::default()).service(
             web::resource("/").to(|| async {
-                NamedFile::open("Cargo.toml")
+                NamedFile::open_async("Cargo.toml")
+                    .await
                     .unwrap()
                     .set_content_encoding(header::ContentEncoding::Identity)
             }),
@@ -585,7 +604,8 @@ mod tests {
     async fn test_named_file_content_encoding_gzip() {
         let srv = test::init_service(App::new().wrap(Compress::default()).service(
             web::resource("/").to(|| async {
-                NamedFile::open("Cargo.toml")
+                NamedFile::open_async("Cargo.toml")
+                    .await
                     .unwrap()
                     .set_content_encoding(header::ContentEncoding::Gzip)
             }),
@@ -611,7 +631,7 @@ mod tests {
     #[actix_rt::test]
     async fn test_named_file_allowed_method() {
         let req = TestRequest::default().method(Method::GET).to_http_request();
-        let file = NamedFile::open("Cargo.toml").unwrap();
+        let file = NamedFile::open_async("Cargo.toml").await.unwrap();
         let resp = file.respond_to(&req).await.unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
     }
@@ -702,8 +722,8 @@ mod tests {
     #[actix_rt::test]
     async fn test_default_handler_file_missing() {
         let st = Files::new("/", ".")
-            .default_handler(|req: ServiceRequest| {
-                ok(req.into_response(HttpResponse::Ok().body("default content")))
+            .default_handler(|req: ServiceRequest| async {
+                Ok(req.into_response(HttpResponse::Ok().body("default content")))
             })
             .new_service(())
             .await
@@ -786,9 +806,8 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_serve_named_file() {
-        let srv =
-            test::init_service(App::new().service(NamedFile::open("Cargo.toml").unwrap()))
-                .await;
+        let factory = NamedFile::open_async("Cargo.toml").await.unwrap();
+        let srv = test::init_service(App::new().service(factory)).await;
 
         let req = TestRequest::get().uri("/Cargo.toml").to_request();
         let res = test::call_service(&srv, req).await;
@@ -805,11 +824,9 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_serve_named_file_prefix() {
-        let srv = test::init_service(
-            App::new()
-                .service(web::scope("/test").service(NamedFile::open("Cargo.toml").unwrap())),
-        )
-        .await;
+        let factory = NamedFile::open_async("Cargo.toml").await.unwrap();
+        let srv =
+            test::init_service(App::new().service(web::scope("/test").service(factory))).await;
 
         let req = TestRequest::get().uri("/test/Cargo.toml").to_request();
         let res = test::call_service(&srv, req).await;
@@ -826,10 +843,8 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_default_service() {
-        let srv = test::init_service(
-            App::new().default_service(NamedFile::open("Cargo.toml").unwrap()),
-        )
-        .await;
+        let factory = NamedFile::open_async("Cargo.toml").await.unwrap();
+        let srv = test::init_service(App::new().default_service(factory)).await;
 
         for route in ["/foobar", "/baz", "/"].iter() {
             let req = TestRequest::get().uri(route).to_request();
@@ -844,8 +859,9 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_default_handler_named_file() {
+        let factory = NamedFile::open_async("Cargo.toml").await.unwrap();
         let st = Files::new("/", ".")
-            .default_handler(NamedFile::open("Cargo.toml").unwrap())
+            .default_handler(factory)
             .new_service(())
             .await
             .unwrap();
@@ -872,4 +888,69 @@ mod tests {
             "inline; filename=\"symlink-test.png\""
         );
     }
+
+    #[actix_rt::test]
+    async fn test_index_with_show_files_listing() {
+        let service = Files::new(".", ".")
+            .index_file("lib.rs")
+            .show_files_listing()
+            .new_service(())
+            .await
+            .unwrap();
+
+        // Serve the index if exists
+        let req = TestRequest::default().uri("/src").to_srv_request();
+        let resp = test::call_service(&service, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        assert_eq!(
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
+            "text/x-rust"
+        );
+
+        // Show files listing, otherwise.
+        let req = TestRequest::default().uri("/tests").to_srv_request();
+        let resp = test::call_service(&service, req).await;
+        assert_eq!(
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
+            "text/html; charset=utf-8"
+        );
+        let bytes = test::read_body(resp).await;
+        assert!(format!("{:?}", bytes).contains("/tests/test.png"));
+    }
+
+    #[actix_rt::test]
+    async fn test_path_filter() {
+        // prevent searching subdirectories
+        let st = Files::new("/", ".")
+            .path_filter(|path, _| path.components().count() == 1)
+            .new_service(())
+            .await
+            .unwrap();
+
+        let req = TestRequest::with_uri("/Cargo.toml").to_srv_request();
+        let resp = test::call_service(&st, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/src/lib.rs").to_srv_request();
+        let resp = test::call_service(&st, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    }
+
+    #[actix_rt::test]
+    async fn test_default_handler_filter() {
+        let st = Files::new("/", ".")
+            .default_handler(|req: ServiceRequest| async {
+                Ok(req.into_response(HttpResponse::Ok().body("default content")))
+            })
+            .path_filter(|path, _| path.extension() == Some("png".as_ref()))
+            .new_service(())
+            .await
+            .unwrap();
+        let req = TestRequest::with_uri("/Cargo.toml").to_srv_request();
+        let resp = test::call_service(&st, req).await;
+
+        assert_eq!(resp.status(), StatusCode::OK);
+        let bytes = test::read_body(resp).await;
+        assert_eq!(bytes, web::Bytes::from_static(b"default content"));
+    }
 }

actix-files/src/named.rs

@@ -1,29 +1,32 @@
+use std::{
+    fmt,
+    fs::Metadata,
+    io,
+    path::{Path, PathBuf},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
 use actix_service::{Service, ServiceFactory};
-use actix_utils::future::{ok, ready, Ready};
-use actix_web::dev::{AppService, HttpServiceFactory, ResourceDef};
-use std::fs::{File, Metadata};
-use std::io;
-use std::ops::{Deref, DerefMut};
-use std::path::{Path, PathBuf};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-#[cfg(unix)]
-use std::os::unix::fs::MetadataExt;
-
 use actix_web::{
-    dev::{BodyEncoding, ServiceRequest, ServiceResponse, SizedStream},
+    body::{self, BoxBody, SizedStream},
+    dev::{
+        AppService, BodyEncoding, HttpServiceFactory, ResourceDef, ServiceRequest,
+        ServiceResponse,
+    },
     http::{
         header::{
-            self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
+            self, Charset, ContentDisposition, ContentEncoding, DispositionParam,
+            DispositionType, ExtendedValue,
         },
-        ContentEncoding, StatusCode,
+        StatusCode,
     },
     Error, HttpMessage, HttpRequest, HttpResponse, Responder,
 };
 use bitflags::bitflags;
+use derive_more::{Deref, DerefMut};
+use futures_core::future::LocalBoxFuture;
 use mime_guess::from_path;
 
-use crate::ChunkedReadFile;
 use crate::{encoding::equiv_utf8_text, range::HttpRange};
 
 bitflags! {
@@ -48,9 +51,9 @@ impl Default for Flags {
 /// use actix_web::App;
 /// use actix_files::NamedFile;
 ///
-/// # fn run() -> Result<(), Box<dyn std::error::Error>> {
-/// let app = App::new()
-///     .service(NamedFile::open("./static/index.html")?);
+/// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
+/// let file = NamedFile::open_async("./static/index.html").await?;
+/// let app = App::new().service(file);
 /// # Ok(())
 /// # }
 /// ```
@@ -62,12 +65,14 @@ impl Default for Flags {
 ///
 /// #[get("/")]
 /// async fn index() -> impl Responder {
-///     NamedFile::open("./static/index.html")
+///     NamedFile::open_async("./static/index.html").await
 /// }
 /// ```
-#[derive(Debug)]
+#[derive(Deref, DerefMut)]
 pub struct NamedFile {
     path: PathBuf,
+    #[deref]
+    #[deref_mut]
     file: File,
     modified: Option<SystemTime>,
     pub(crate) md: Metadata,
@@ -78,6 +83,39 @@ pub struct NamedFile {
     pub(crate) encoding: Option<ContentEncoding>,
 }
 
+impl fmt::Debug for NamedFile {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NamedFile")
+            .field("path", &self.path)
+            .field(
+                "file",
+                #[cfg(feature = "experimental-io-uring")]
+                {
+                    &"tokio_uring::File"
+                },
+                #[cfg(not(feature = "experimental-io-uring"))]
+                {
+                    &self.file
+                },
+            )
+            .field("modified", &self.modified)
+            .field("md", &self.md)
+            .field("flags", &self.flags)
+            .field("status_code", &self.status_code)
+            .field("content_type", &self.content_type)
+            .field("content_disposition", &self.content_disposition)
+            .field("encoding", &self.encoding)
+            .finish()
+    }
+}
+
+#[cfg(not(feature = "experimental-io-uring"))]
+pub(crate) use std::fs::File;
+#[cfg(feature = "experimental-io-uring")]
+pub(crate) use tokio_uring::fs::File;
+
+use super::chunked;
+
 impl NamedFile {
     /// Creates an instance from a previously opened file.
     ///
@@ -85,8 +123,7 @@ impl NamedFile {
     /// `ContentDisposition` headers.
     ///
     /// # Examples
-    ///
-    /// ```
+    /// ```ignore
     /// use actix_files::NamedFile;
     /// use std::io::{self, Write};
     /// use std::env;
@@ -147,7 +184,30 @@ impl NamedFile {
             (ct, cd)
         };
 
-        let md = file.metadata()?;
+        let md = {
+            #[cfg(not(feature = "experimental-io-uring"))]
+            {
+                file.metadata()?
+            }
+
+            #[cfg(feature = "experimental-io-uring")]
+            {
+                use std::os::unix::prelude::{AsRawFd, FromRawFd};
+
+                let fd = file.as_raw_fd();
+
+                // SAFETY: fd is borrowed and lives longer than the unsafe block
+                unsafe {
+                    let file = std::fs::File::from_raw_fd(fd);
+                    let md = file.metadata();
+                    // SAFETY: forget the fd before exiting block in success or error case but don't
+                    // run destructor (that would close file handle)
+                    std::mem::forget(file);
+                    md?
+                }
+            }
+        };
+
         let modified = md.modified().ok();
         let encoding = None;
 
@@ -164,17 +224,45 @@ impl NamedFile {
         })
     }
 
+    #[cfg(not(feature = "experimental-io-uring"))]
     /// Attempts to open a file in read-only mode.
     ///
     /// # Examples
-    ///
     /// ```
     /// use actix_files::NamedFile;
-    ///
     /// let file = NamedFile::open("foo.txt");
     /// ```
     pub fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
-        Self::from_file(File::open(&path)?, path)
+        let file = File::open(&path)?;
+        Self::from_file(file, path)
+    }
+
+    /// Attempts to open a file asynchronously in read-only mode.
+    ///
+    /// When the `experimental-io-uring` crate feature is enabled, this will be async.
+    /// Otherwise, it will be just like [`open`][Self::open].
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_files::NamedFile;
+    /// # async fn open() {
+    /// let file = NamedFile::open_async("foo.txt").await.unwrap();
+    /// # }
+    /// ```
+    pub async fn open_async<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
+        let file = {
+            #[cfg(not(feature = "experimental-io-uring"))]
+            {
+                File::open(&path)?
+            }
+
+            #[cfg(feature = "experimental-io-uring")]
+            {
+                File::open(&path).await?
+            }
+        };
+
+        Self::from_file(file, path)
     }
 
     /// Returns reference to the underlying `File` object.
@@ -186,13 +274,12 @@ impl NamedFile {
     /// Retrieve the path of this file.
     ///
     /// # Examples
-    ///
     /// ```
     /// # use std::io;
     /// use actix_files::NamedFile;
     ///
-    /// # fn path() -> io::Result<()> {
-    /// let file = NamedFile::open("test.txt")?;
+    /// # async fn path() -> io::Result<()> {
+    /// let file = NamedFile::open_async("test.txt").await?;
     /// assert_eq!(file.path().as_os_str(), "foo.txt");
     /// # Ok(())
     /// # }
@@ -277,14 +364,18 @@ impl NamedFile {
         self
     }
 
+    /// Creates a etag in a format is similar to Apache's.
     pub(crate) fn etag(&self) -> Option<header::EntityTag> {
-        // This etag format is similar to Apache's.
         self.modified.as_ref().map(|mtime| {
             let ino = {
                 #[cfg(unix)]
                 {
+                    #[cfg(unix)]
+                    use std::os::unix::fs::MetadataExt as _;
+
                     self.md.ino()
                 }
+
                 #[cfg(not(unix))]
                 {
                     0
@@ -310,7 +401,7 @@ impl NamedFile {
     }
 
     /// Creates an `HttpResponse` with file as a streaming body.
-    pub fn into_response(self, req: &HttpRequest) -> HttpResponse {
+    pub fn into_response(self, req: &HttpRequest) -> HttpResponse<BoxBody> {
         if self.status_code != StatusCode::OK {
             let mut res = HttpResponse::build(self.status_code);
 
@@ -332,7 +423,7 @@ impl NamedFile {
                 res.encoding(current_encoding);
             }
 
-            let reader = ChunkedReadFile::new(self.md.len(), 0, self.file);
+            let reader = chunked::new_chunked_read(self.md.len(), 0, self.file);
 
             return res.streaming(reader);
         }
@@ -355,8 +446,8 @@ impl NamedFile {
         } else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
             (last_modified, req.get_header())
         {
-            let t1: SystemTime = m.clone().into();
-            let t2: SystemTime = since.clone().into();
+            let t1: SystemTime = (*m).into();
+            let t2: SystemTime = (*since).into();
 
             match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
                 (Ok(t1), Ok(t2)) => t1.as_secs() > t2.as_secs(),
@@ -374,8 +465,8 @@ impl NamedFile {
         } else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
             (last_modified, req.get_header())
         {
-            let t1: SystemTime = m.clone().into();
-            let t2: SystemTime = since.clone().into();
+            let t1: SystemTime = (*m).into();
+            let t2: SystemTime = (*since).into();
 
             match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
                 (Ok(t1), Ok(t2)) => t1.as_secs() <= t2.as_secs(),
@@ -385,17 +476,17 @@ impl NamedFile {
             false
         };
 
-        let mut resp = HttpResponse::build(self.status_code);
+        let mut res = HttpResponse::build(self.status_code);
 
         if self.flags.contains(Flags::PREFER_UTF8) {
             let ct = equiv_utf8_text(self.content_type.clone());
-            resp.insert_header((header::CONTENT_TYPE, ct.to_string()));
+            res.insert_header((header::CONTENT_TYPE, ct.to_string()));
         } else {
-            resp.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
+            res.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
         }
 
         if self.flags.contains(Flags::CONTENT_DISPOSITION) {
-            resp.insert_header((
+            res.insert_header((
                 header::CONTENT_DISPOSITION,
                 self.content_disposition.to_string(),
             ));
@@ -403,18 +494,18 @@ impl NamedFile {
 
         // default compressing
         if let Some(current_encoding) = self.encoding {
-            resp.encoding(current_encoding);
+            res.encoding(current_encoding);
         }
 
         if let Some(lm) = last_modified {
-            resp.insert_header((header::LAST_MODIFIED, lm.to_string()));
+            res.insert_header((header::LAST_MODIFIED, lm.to_string()));
         }
 
         if let Some(etag) = etag {
-            resp.insert_header((header::ETAG, etag.to_string()));
+            res.insert_header((header::ETAG, etag.to_string()));
         }
 
-        resp.insert_header((header::ACCEPT_RANGES, "bytes"));
+        res.insert_header((header::ACCEPT_RANGES, "bytes"));
 
         let mut length = self.md.len();
         let mut offset = 0;
@@ -426,47 +517,36 @@ impl NamedFile {
                     length = ranges[0].length;
                     offset = ranges[0].start;
 
-                    resp.encoding(ContentEncoding::Identity);
-                    resp.insert_header((
+                    res.encoding(ContentEncoding::Identity);
+                    res.insert_header((
                         header::CONTENT_RANGE,
                         format!("bytes {}-{}/{}", offset, offset + length - 1, self.md.len()),
                     ));
                 } else {
-                    resp.insert_header((header::CONTENT_RANGE, format!("bytes */{}", length)));
-                    return resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish();
+                    res.insert_header((header::CONTENT_RANGE, format!("bytes */{}", length)));
+                    return res.status(StatusCode::RANGE_NOT_SATISFIABLE).finish();
                 };
             } else {
-                return resp.status(StatusCode::BAD_REQUEST).finish();
+                return res.status(StatusCode::BAD_REQUEST).finish();
             };
         };
 
         if precondition_failed {
-            return resp.status(StatusCode::PRECONDITION_FAILED).finish();
+            return res.status(StatusCode::PRECONDITION_FAILED).finish();
         } else if not_modified {
-            return resp.status(StatusCode::NOT_MODIFIED).finish();
+            return res
+                .status(StatusCode::NOT_MODIFIED)
+                .body(body::None::new())
+                .map_into_boxed_body();
         }
 
-        let reader = ChunkedReadFile::new(length, offset, self.file);
+        let reader = chunked::new_chunked_read(length, offset, self.file);
 
         if offset != 0 || length != self.md.len() {
-            resp.status(StatusCode::PARTIAL_CONTENT);
+            res.status(StatusCode::PARTIAL_CONTENT);
         }
 
-        resp.body(SizedStream::new(length, reader))
-    }
-}
-
-impl Deref for NamedFile {
-    type Target = File;
-
-    fn deref(&self) -> &File {
-        &self.file
-    }
-}
-
-impl DerefMut for NamedFile {
-    fn deref_mut(&mut self) -> &mut File {
-        &mut self.file
+        res.body(SizedStream::new(length, reader))
     }
 }
 
@@ -511,7 +591,9 @@ fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
 }
 
 impl Responder for NamedFile {
-    fn respond_to(self, req: &HttpRequest) -> HttpResponse {
+    type Body = BoxBody;
+
+    fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
         self.into_response(req)
     }
 }
@@ -520,14 +602,16 @@ impl ServiceFactory<ServiceRequest> for NamedFile {
     type Response = ServiceResponse;
     type Error = Error;
     type Config = ();
-    type InitError = ();
     type Service = NamedFileService;
-    type Future = Ready<Result<Self::Service, ()>>;
+    type InitError = ();
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        ok(NamedFileService {
+        let service = NamedFileService {
             path: self.path.clone(),
-        })
+        };
+
+        Box::pin(async move { Ok(service) })
     }
 }
 
@@ -540,18 +624,19 @@ pub struct NamedFileService {
 impl Service<ServiceRequest> for NamedFileService {
     type Response = ServiceResponse;
     type Error = Error;
-    type Future = Ready<Result<Self::Response, Self::Error>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 
     actix_service::always_ready!();
 
     fn call(&self, req: ServiceRequest) -> Self::Future {
         let (req, _) = req.into_parts();
-        ready(
-            NamedFile::open(&self.path)
-                .map_err(|e| e.into())
-                .map(|f| f.into_response(&req))
-                .map(|res| ServiceResponse::new(req, res)),
-        )
+
+        let path = self.path.clone();
+        Box::pin(async move {
+            let file = NamedFile::open_async(path).await?;
+            let res = file.into_response(&req);
+            Ok(ServiceResponse::new(req, res))
+        })
     }
 }
 

actix-files/src/path_buf.rs

@@ -8,7 +8,7 @@ use actix_web::{dev::Payload, FromRequest, HttpRequest};
 
 use crate::error::UriSegmentError;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) struct PathBufWrap(PathBuf);
 
 impl FromStr for PathBufWrap {
@@ -21,6 +21,8 @@ impl FromStr for PathBufWrap {
 
 impl PathBufWrap {
     /// Parse a path, giving the choice of allowing hidden files to be considered valid segments.
+    ///
+    /// Path traversal is guarded by this method.
     pub fn parse_path(path: &str, hidden_files: bool) -> Result<Self, UriSegmentError> {
         let mut buf = PathBuf::new();
 
@@ -59,7 +61,6 @@ impl AsRef<Path> for PathBufWrap {
 impl FromRequest for PathBufWrap {
     type Error = UriSegmentError;
     type Future = Ready<Result<Self, Self::Error>>;
-    type Config = ();
 
     fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
         ready(req.match_info().path().parse())
@@ -116,4 +117,24 @@ mod tests {
             PathBuf::from_iter(vec!["test", ".tt"])
         );
     }
+
+    #[test]
+    fn path_traversal() {
+        assert_eq!(
+            PathBufWrap::parse_path("/../README.md", false).unwrap().0,
+            PathBuf::from_iter(vec!["README.md"])
+        );
+
+        assert_eq!(
+            PathBufWrap::parse_path("/../README.md", true).unwrap().0,
+            PathBuf::from_iter(vec!["README.md"])
+        );
+
+        assert_eq!(
+            PathBufWrap::parse_path("/../../../../../../../../../../etc/passwd", false)
+                .unwrap()
+                .0,
+            PathBuf::from_iter(vec!["etc/passwd"])
+        );
+    }
 }

actix-files/src/service.rs

@@ -1,9 +1,8 @@
-use std::{fmt, io, path::PathBuf, rc::Rc};
+use std::{fmt, io, ops::Deref, path::PathBuf, rc::Rc};
 
-use actix_service::Service;
-use actix_utils::future::ok;
 use actix_web::{
-    dev::{ServiceRequest, ServiceResponse},
+    body::BoxBody,
+    dev::{Service, ServiceRequest, ServiceResponse},
     error::Error,
     guard::Guard,
     http::{header, Method},
@@ -13,11 +12,22 @@ use futures_core::future::LocalBoxFuture;
 
 use crate::{
     named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride, NamedFile,
-    PathBufWrap,
+    PathBufWrap, PathFilter,
 };
 
 /// Assembled file serving service.
-pub struct FilesService {
+#[derive(Clone)]
+pub struct FilesService(pub(crate) Rc<FilesServiceInner>);
+
+impl Deref for FilesService {
+    type Target = FilesServiceInner;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+
+pub struct FilesServiceInner {
     pub(crate) directory: PathBuf,
     pub(crate) index: Option<String>,
     pub(crate) show_index: bool,
@@ -25,25 +35,56 @@ pub struct FilesService {
     pub(crate) default: Option<HttpService>,
     pub(crate) renderer: Rc<DirectoryRenderer>,
     pub(crate) mime_override: Option<Rc<MimeOverride>>,
+    pub(crate) path_filter: Option<Rc<PathFilter>>,
     pub(crate) file_flags: named::Flags,
     pub(crate) guards: Option<Rc<dyn Guard>>,
     pub(crate) hidden_files: bool,
 }
 
+impl fmt::Debug for FilesServiceInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("FilesServiceInner")
+    }
+}
+
 impl FilesService {
-    fn handle_err(
+    async fn handle_err(
         &self,
         err: io::Error,
         req: ServiceRequest,
-    ) -> LocalBoxFuture<'static, Result<ServiceResponse, Error>> {
+    ) -> Result<ServiceResponse, Error> {
         log::debug!("error handling {}: {}", req.path(), err);
 
         if let Some(ref default) = self.default {
-            Box::pin(default.call(req))
+            default.call(req).await
         } else {
-            Box::pin(ok(req.error_response(err)))
+            Ok(req.error_response(err))
         }
     }
+
+    fn serve_named_file(
+        &self,
+        req: ServiceRequest,
+        mut named_file: NamedFile,
+    ) -> ServiceResponse {
+        if let Some(ref mime_override) = self.mime_override {
+            let new_disposition = mime_override(&named_file.content_type.type_());
+            named_file.content_disposition.disposition = new_disposition;
+        }
+        named_file.flags = self.file_flags;
+
+        let (req, _) = req.into_parts();
+        let res = named_file.into_response(&req);
+        ServiceResponse::new(req, res)
+    }
+
+    fn show_index(&self, req: ServiceRequest, path: PathBuf) -> ServiceResponse {
+        let dir = Directory::new(self.directory.clone(), path);
+
+        let (req, _) = req.into_parts();
+
+        (self.renderer)(&dir, &req).unwrap_or_else(|e| ServiceResponse::from_err(e, req))
+    }
 }
 
 impl fmt::Debug for FilesService {
@@ -53,104 +94,102 @@ impl fmt::Debug for FilesService {
 }
 
 impl Service<ServiceRequest> for FilesService {
-    type Response = ServiceResponse;
+    type Response = ServiceResponse<BoxBody>;
     type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 
     actix_service::always_ready!();
 
     fn call(&self, req: ServiceRequest) -> Self::Future {
         let is_method_valid = if let Some(guard) = &self.guards {
             // execute user defined guards
-            (**guard).check(req.head())
+            (**guard).check(&req.guard_ctx())
         } else {
             // default behavior
             matches!(*req.method(), Method::HEAD | Method::GET)
         };
 
-        if !is_method_valid {
-            return Box::pin(ok(req.into_response(
-                actix_web::HttpResponse::MethodNotAllowed()
-                    .insert_header(header::ContentType(mime::TEXT_PLAIN_UTF_8))
-                    .body("Request did not meet this resource's requirements."),
-            )));
-        }
+        let this = self.clone();
 
-        let real_path =
-            match PathBufWrap::parse_path(req.match_info().path(), self.hidden_files) {
-                Ok(item) => item,
-                Err(e) => return Box::pin(ok(req.error_response(e))),
-            };
-
-        // full file path
-        let path = self.directory.join(&real_path);
-        if let Err(err) = path.canonicalize() {
-            return Box::pin(self.handle_err(err, req));
-        }
-
-        if path.is_dir() {
-            if self.redirect_to_slash
-                && !req.path().ends_with('/')
-                && (self.index.is_some() || self.show_index)
-            {
-                let redirect_to = format!("{}/", req.path());
-
-                return Box::pin(ok(req.into_response(
-                    HttpResponse::Found()
-                        .insert_header((header::LOCATION, redirect_to))
-                        .finish(),
-                )));
+        Box::pin(async move {
+            if !is_method_valid {
+                return Ok(req.into_response(
+                    actix_web::HttpResponse::MethodNotAllowed()
+                        .insert_header(header::ContentType(mime::TEXT_PLAIN_UTF_8))
+                        .body("Request did not meet this resource's requirements."),
+                ));
             }
 
-            if let Some(ref redir_index) = self.index {
-                let path = path.join(redir_index);
+            let real_path =
+                match PathBufWrap::parse_path(req.match_info().path(), this.hidden_files) {
+                    Ok(item) => item,
+                    Err(e) => return Ok(req.error_response(e)),
+                };
 
-                match NamedFile::open(path) {
+            if let Some(filter) = &this.path_filter {
+                if !filter(real_path.as_ref(), req.head()) {
+                    if let Some(ref default) = this.default {
+                        return default.call(req).await;
+                    } else {
+                        return Ok(
+                            req.into_response(actix_web::HttpResponse::NotFound().finish())
+                        );
+                    }
+                }
+            }
+
+            // full file path
+            let path = this.directory.join(&real_path);
+            if let Err(err) = path.canonicalize() {
+                return this.handle_err(err, req).await;
+            }
+
+            if path.is_dir() {
+                if this.redirect_to_slash
+                    && !req.path().ends_with('/')
+                    && (this.index.is_some() || this.show_index)
+                {
+                    let redirect_to = format!("{}/", req.path());
+
+                    return Ok(req.into_response(
+                        HttpResponse::Found()
+                            .insert_header((header::LOCATION, redirect_to))
+                            .finish(),
+                    ));
+                }
+
+                match this.index {
+                    Some(ref index) => {
+                        let named_path = path.join(index);
+                        match NamedFile::open_async(named_path).await {
+                            Ok(named_file) => Ok(this.serve_named_file(req, named_file)),
+                            Err(_) if this.show_index => Ok(this.show_index(req, path)),
+                            Err(err) => this.handle_err(err, req).await,
+                        }
+                    }
+                    None if this.show_index => Ok(this.show_index(req, path)),
+                    _ => Ok(ServiceResponse::from_err(
+                        FilesError::IsDirectory,
+                        req.into_parts().0,
+                    )),
+                }
+            } else {
+                match NamedFile::open_async(&path).await {
                     Ok(mut named_file) => {
-                        if let Some(ref mime_override) = self.mime_override {
+                        if let Some(ref mime_override) = this.mime_override {
                             let new_disposition =
                                 mime_override(&named_file.content_type.type_());
                             named_file.content_disposition.disposition = new_disposition;
                         }
-                        named_file.flags = self.file_flags;
+                        named_file.flags = this.file_flags;
 
                         let (req, _) = req.into_parts();
                         let res = named_file.into_response(&req);
-                        Box::pin(ok(ServiceResponse::new(req, res)))
+                        Ok(ServiceResponse::new(req, res))
                     }
-                    Err(err) => self.handle_err(err, req),
+                    Err(err) => this.handle_err(err, req).await,
                 }
-            } else if self.show_index {
-                let dir = Directory::new(self.directory.clone(), path);
-
-                let (req, _) = req.into_parts();
-                let x = (self.renderer)(&dir, &req);
-
-                Box::pin(match x {
-                    Ok(resp) => ok(resp),
-                    Err(err) => ok(ServiceResponse::from_err(err, req)),
-                })
-            } else {
-                Box::pin(ok(ServiceResponse::from_err(
-                    FilesError::IsDirectory,
-                    req.into_parts().0,
-                )))
             }
-        } else {
-            match NamedFile::open(path) {
-                Ok(mut named_file) => {
-                    if let Some(ref mime_override) = self.mime_override {
-                        let new_disposition = mime_override(&named_file.content_type.type_());
-                        named_file.content_disposition.disposition = new_disposition;
-                    }
-                    named_file.flags = self.file_flags;
-
-                    let (req, _) = req.into_parts();
-                    let res = named_file.into_response(&req);
-                    Box::pin(ok(ServiceResponse::new(req, res)))
-                }
-                Err(err) => self.handle_err(err, req),
-            }
-        }
+        })
     }
 }

actix-files/tests/encoding.rs

@@ -8,7 +8,7 @@ use actix_web::{
     App,
 };
 
-#[actix_rt::test]
+#[actix_web::test]
 async fn test_utf8_file_contents() {
     // use default ISO-8859-1 encoding
     let srv = test::init_service(App::new().service(Files::new("/", "./tests"))).await;

actix-files/tests/guard.rs

@@ -7,7 +7,7 @@ use actix_web::{
 };
 use bytes::Bytes;
 
-#[actix_rt::test]
+#[actix_web::test]
 async fn test_guard_filter() {
     let srv = test::init_service(
         App::new()

actix-files/tests/traversal.rs

@@ -0,0 +1,27 @@
+use actix_files::Files;
+use actix_web::{
+    http::StatusCode,
+    test::{self, TestRequest},
+    App,
+};
+
+#[actix_rt::test]
+async fn test_directory_traversal_prevention() {
+    let srv = test::init_service(App::new().service(Files::new("/", "./tests"))).await;
+
+    let req =
+        TestRequest::with_uri("/../../../../../../../../../../../etc/passwd").to_request();
+    let res = test::call_service(&srv, req).await;
+    assert_eq!(res.status(), StatusCode::NOT_FOUND);
+
+    let req = TestRequest::with_uri(
+        "/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd",
+    )
+    .to_request();
+    let res = test::call_service(&srv, req).await;
+    assert_eq!(res.status(), StatusCode::NOT_FOUND);
+
+    let req = TestRequest::with_uri("/%00/etc/passwd%00").to_request();
+    let res = test::call_service(&srv, req).await;
+    assert_eq!(res.status(), StatusCode::NOT_FOUND);
+}

actix-http-test/CHANGES.md

@@ -3,98 +3,132 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 3.0.0-beta.10 - 2021-12-27
+- Update `actix-server` to `2.0.0-rc.2`. [#2550]
+
+[#2550]: https://github.com/actix/actix-web/pull/2550
+
+
+## 3.0.0-beta.9 - 2021-12-11
+- No significant changes since `3.0.0-beta.8`.
+
+
+## 3.0.0-beta.8 - 2021-11-30
+- Update `actix-tls` to `3.0.0-rc.1`. [#2474]
+
+[#2474]: https://github.com/actix/actix-web/pull/2474
+
+
+## 3.0.0-beta.7 - 2021-11-22
+- Fix compatibility with experimental `io-uring` feature of `actix-rt`. [#2408]
+
+[#2408]: https://github.com/actix/actix-web/pull/2408
+
+
+## 3.0.0-beta.6 - 2021-11-15
+- `TestServer::stop` is now async and will wait for the server and system to shutdown. [#2442]
+- Update `actix-server` to `2.0.0-beta.9`. [#2442]
+- Minimum supported Rust version (MSRV) is now 1.52.
+
+[#2442]: https://github.com/actix/actix-web/pull/2442
+
+
+## 3.0.0-beta.5 - 2021-09-09
+- Minimum supported Rust version (MSRV) is now 1.51.
+
+
 ## 3.0.0-beta.4 - 2021-04-02
-* Added `TestServer::client_headers` method. [#2097]
+- Added `TestServer::client_headers` method. [#2097]
 
 [#2097]: https://github.com/actix/actix-web/pull/2097
 
 
 ## 3.0.0-beta.3 - 2021-03-09
-* No notable changes.
+- No notable changes.
 
 
 ## 3.0.0-beta.2 - 2021-02-10
-* No notable changes.
+- No notable changes.
 
 
 ## 3.0.0-beta.1 - 2021-01-07
-* Update `bytes` to `1.0`. [#1813]
+- Update `bytes` to `1.0`. [#1813]
 
 [#1813]: https://github.com/actix/actix-web/pull/1813
 
 
 ## 2.1.0 - 2020-11-25
-* Add ability to set address for `TestServer`. [#1645]
-* Upgrade `base64` to `0.13`.
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
+- Add ability to set address for `TestServer`. [#1645]
+- Upgrade `base64` to `0.13`.
+- Upgrade `serde_urlencoded` to `0.7`. [#1773]
 
 [#1773]: https://github.com/actix/actix-web/pull/1773
 [#1645]: https://github.com/actix/actix-web/pull/1645
 
 
 ## 2.0.0 - 2020-09-11
-* Update actix-codec and actix-utils dependencies.
+- Update actix-codec and actix-utils dependencies.
 
 
 ## 2.0.0-alpha.1 - 2020-05-23
-* Update the `time` dependency to 0.2.7
-* Update `actix-connect` dependency to 2.0.0-alpha.2
-* Make `test_server` `async` fn.
-* Bump minimum supported Rust version to 1.40
-* Replace deprecated `net2` crate with `socket2`
-* Update `base64` dependency to 0.12
-* Update `env_logger` dependency to 0.7
+- Update the `time` dependency to 0.2.7
+- Update `actix-connect` dependency to 2.0.0-alpha.2
+- Make `test_server` `async` fn.
+- Bump minimum supported Rust version to 1.40
+- Replace deprecated `net2` crate with `socket2`
+- Update `base64` dependency to 0.12
+- Update `env_logger` dependency to 0.7
 
 ## 1.0.0 - 2019-12-13
-* Replaced `TestServer::start()` with `test_server()`
+- Replaced `TestServer::start()` with `test_server()`
 
 
 ## 1.0.0-alpha.3 - 2019-12-07
-* Migrate to `std::future`
+- Migrate to `std::future`
 
 
 ## 0.2.5 - 2019-09-17
-* Update serde_urlencoded to "0.6.1"
-* Increase TestServerRuntime timeouts from 500ms to 3000ms
-* Do not override current `System`
+- Update serde_urlencoded to "0.6.1"
+- Increase TestServerRuntime timeouts from 500ms to 3000ms
+- Do not override current `System`
 
 
 ## 0.2.4 - 2019-07-18
-* Update actix-server to 0.6
+- Update actix-server to 0.6
 
 
 ## 0.2.3 - 2019-07-16
-* Add `delete`, `options`, `patch` methods to `TestServerRunner`
+- Add `delete`, `options`, `patch` methods to `TestServerRunner`
 
 
 ## 0.2.2 - 2019-06-16
-* Add .put() and .sput() methods
+- Add .put() and .sput() methods
 
 
 ## 0.2.1 - 2019-06-05
-* Add license files
+- Add license files
 
 
 ## 0.2.0 - 2019-05-12
-* Update awc and actix-http deps
+- Update awc and actix-http deps
 
 
 ## 0.1.1 - 2019-04-24
-* Always make new connection for http client
+- Always make new connection for http client
 
 
 ## 0.1.0 - 2019-04-16
-* No changes
+- No changes
 
 
 ## 0.1.0-alpha.3 - 2019-04-02
-* Request functions accept path #743
+- Request functions accept path #743
 
 
 ## 0.1.0-alpha.2 - 2019-03-29
-* Added TestServerRuntime::load_body() method
-* Update actix-http and awc libraries
+- Added TestServerRuntime::load_body() method
+- Update actix-http and awc libraries
 
 
 ## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl
+- Initial impl

actix-http-test/Cargo.toml

@@ -1,18 +1,18 @@
 [package]
 name = "actix-http-test"
-version = "3.0.0-beta.4"
+version = "3.0.0-beta.10"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Various helpers for Actix applications to use during testing"
-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-http-test/"
-categories = ["network-programming", "asynchronous",
-              "web-programming::http-server",
-              "web-programming::websocket"]
+categories = [
+    "network-programming",
+    "asynchronous",
+    "web-programming::http-server",
+    "web-programming::websocket",
+]
 license = "MIT OR Apache-2.0"
-exclude = [".gitignore", ".cargo/config"]
 edition = "2018"
 
 [package.metadata.docs.rs]
@@ -30,26 +30,26 @@ openssl = ["tls-openssl", "awc/openssl"]
 
 [dependencies]
 actix-service = "2.0.0"
-actix-codec = "0.4.0"
-actix-tls = "3.0.0-beta.5"
+actix-codec = "0.4.1"
+actix-tls = "3.0.0"
 actix-utils = "3.0.0"
 actix-rt = "2.2"
-actix-server = "2.0.0-beta.3"
-awc = { version = "3.0.0-beta.6", default-features = false }
+actix-server = "2.0.0-rc.2"
+awc = { version = "3.0.0-beta.16", default-features = false }
 
 base64 = "0.13"
 bytes = "1"
 futures-core = { version = "0.3.7", default-features = false }
-http = "0.2.2"
+http = "0.2.5"
 log = "0.4"
 socket2 = "0.4"
 serde = "1.0"
 serde_json = "1.0"
 slab = "0.4"
 serde_urlencoded = "0.7"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
 tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
+tokio = { version = "1.8.4", features = ["sync"] }
 
 [dev-dependencies]
-actix-web = { version = "4.0.0-beta.7", default-features = false, features = ["cookies"] }
-actix-http = "3.0.0-beta.7"
+actix-web = { version = "4.0.0-beta.17", default-features = false, features = ["cookies"] }
+actix-http = "3.0.0-beta.17"

actix-http-test/README.md

@@ -3,13 +3,15 @@
 > Various helpers for Actix applications to use during testing.
 
 [![crates.io](https://img.shields.io/crates/v/actix-http-test?label=latest)](https://crates.io/crates/actix-http-test)
-[![Documentation](https://docs.rs/actix-http-test/badge.svg?version=3.0.0-beta.4)](https://docs.rs/actix-http-test/3.0.0-beta.4)
+[![Documentation](https://docs.rs/actix-http-test/badge.svg?version=3.0.0-beta.10)](https://docs.rs/actix-http-test/3.0.0-beta.10)
+[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http-test)
-[![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0-beta.4)
-[![Join the chat at https://gitter.im/actix/actix-web](https://badges.gitter.im/actix/actix-web.svg)](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+<br>
+[![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0-beta.10/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0-beta.10)
+[![Download](https://img.shields.io/crates/d/actix-http-test.svg)](https://crates.io/crates/actix-http-test)
+[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-http-test)
-- [Chat on Gitter](https://gitter.im/actix/actix-web)
-- Minimum Supported Rust Version (MSRV): 1.46.0
+- Minimum Supported Rust Version (MSRV): 1.52

actix-http-test/src/lib.rs

@@ -1,48 +1,48 @@
 //! Various helpers for Actix applications to use during testing.
 
-#![deny(rust_2018_idioms)]
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![warn(future_incompatible)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 #[cfg(feature = "openssl")]
 extern crate tls_openssl as openssl;
 
-use std::sync::mpsc;
-use std::{net, thread, time};
+use std::{net, thread, time::Duration};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::{net::TcpStream, System};
-use actix_server::{Server, ServiceFactory};
+use actix_server::{Server, ServerServiceFactory};
 use awc::{
-    error::PayloadError, http::HeaderMap, ws, Client, ClientRequest, ClientResponse, Connector,
+    error::PayloadError, http::header::HeaderMap, ws, Client, ClientRequest, ClientResponse,
+    Connector,
 };
 use bytes::Bytes;
 use futures_core::stream::Stream;
 use http::Method;
 use socket2::{Domain, Protocol, Socket, Type};
+use tokio::sync::mpsc;
 
-/// Start test server
+/// Start test server.
 ///
-/// `TestServer` is very simple test server that simplify process of writing
-/// integration tests cases for actix web applications.
+/// `TestServer` is very simple test server that simplify process of writing integration tests cases
+/// for HTTP applications.
 ///
 /// # Examples
-///
-/// ```
+/// ```no_run
 /// use actix_http::HttpService;
-/// use actix_http_test::TestServer;
+/// use actix_http_test::test_server;
 /// use actix_web::{web, App, HttpResponse, Error};
 ///
 /// async fn my_handler() -> Result<HttpResponse, Error> {
 ///     Ok(HttpResponse::Ok().into())
 /// }
 ///
-/// #[actix_rt::test]
+/// #[actix_web::test]
 /// async fn test_example() {
-///     let mut srv = TestServer::start(
-///         || HttpService::new(
-///             App::new().service(
-///                 web::resource("/").to(my_handler))
+///     let mut srv = TestServer::start(||
+///         HttpService::new(
+///             App::new().service(web::resource("/").to(my_handler))
 ///         )
 ///     );
 ///
@@ -51,77 +51,91 @@ use socket2::{Domain, Protocol, Socket, Type};
 ///     assert!(response.status().is_success());
 /// }
 /// ```
-pub async fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
+pub async fn test_server<F: ServerServiceFactory<TcpStream>>(factory: F) -> TestServer {
     let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
     test_server_with_addr(tcp, factory).await
 }
 
-/// Start [`test server`](test_server()) on a concrete Address
-pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
+/// Start [`test server`](test_server()) on an existing address binding.
+pub async fn test_server_with_addr<F: ServerServiceFactory<TcpStream>>(
     tcp: net::TcpListener,
     factory: F,
 ) -> TestServer {
-    let (tx, rx) = mpsc::channel();
+    let (started_tx, started_rx) = std::sync::mpsc::channel();
+    let (thread_stop_tx, thread_stop_rx) = mpsc::channel(1);
 
     // run server in separate thread
     thread::spawn(move || {
-        let sys = System::new();
-        let local_addr = tcp.local_addr().unwrap();
+        System::new().block_on(async move {
+            let local_addr = tcp.local_addr().unwrap();
 
-        let srv = Server::build()
-            .listen("test", tcp, factory)?
-            .workers(1)
-            .disable_signals();
+            let srv = Server::build()
+                .workers(1)
+                .disable_signals()
+                .system_exit()
+                .listen("test", tcp, factory)
+                .expect("test server could not be created");
 
-        sys.block_on(async {
-            srv.run();
-            tx.send((System::current(), local_addr)).unwrap();
+            let srv = srv.run();
+            started_tx
+                .send((System::current(), srv.handle(), local_addr))
+                .unwrap();
+
+            // drive server loop
+            srv.await.unwrap();
         });
 
-        sys.run()
+        // notify TestServer that server and system have shut down
+        // all thread managed resources should be dropped at this point
+        let _ = thread_stop_tx.send(());
     });
 
-    let (system, addr) = rx.recv().unwrap();
+    let (system, server, addr) = started_rx.recv().unwrap();
 
     let client = {
+        #[cfg(feature = "openssl")]
         let connector = {
-            #[cfg(feature = "openssl")]
-            {
-                use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
+            use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
 
-                let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
-                builder.set_verify(SslVerifyMode::NONE);
-                let _ = builder
-                    .set_alpn_protos(b"\x02h2\x08http/1.1")
-                    .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
-                Connector::new()
-                    .conn_lifetime(time::Duration::from_secs(0))
-                    .timeout(time::Duration::from_millis(30000))
-                    .ssl(builder.build())
-            }
-            #[cfg(not(feature = "openssl"))]
-            {
-                Connector::new()
-                    .conn_lifetime(time::Duration::from_secs(0))
-                    .timeout(time::Duration::from_millis(30000))
-            }
+            let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
+
+            builder.set_verify(SslVerifyMode::NONE);
+            let _ = builder
+                .set_alpn_protos(b"\x02h2\x08http/1.1")
+                .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
+
+            Connector::new()
+                .conn_lifetime(Duration::from_secs(0))
+                .timeout(Duration::from_millis(30000))
+                .openssl(builder.build())
+        };
+
+        #[cfg(not(feature = "openssl"))]
+        let connector = {
+            Connector::new()
+                .conn_lifetime(Duration::from_secs(0))
+                .timeout(Duration::from_millis(30000))
         };
 
         Client::builder().connector(connector).finish()
     };
 
     TestServer {
-        addr,
+        server,
         client,
         system,
+        addr,
+        thread_stop_rx,
     }
 }
 
 /// Test server controller
 pub struct TestServer {
+    server: actix_server::ServerHandle,
+    client: awc::Client,
+    system: actix_rt::System,
     addr: net::SocketAddr,
-    client: Client,
-    system: System,
+    thread_stop_rx: mpsc::Receiver<()>,
 }
 
 impl TestServer {
@@ -258,15 +272,32 @@ impl TestServer {
         self.client.headers()
     }
 
-    /// Stop HTTP server
-    fn stop(&mut self) {
+    /// Stop HTTP server.
+    ///
+    /// Waits for spawned `Server` and `System` to (force) shutdown.
+    pub async fn stop(&mut self) {
+        // signal server to stop
+        self.server.stop(false).await;
+
+        // also signal system to stop
+        // though this is handled by `ServerBuilder::exit_system` too
         self.system.stop();
+
+        // wait for thread to be stopped but don't care about result
+        let _ = self.thread_stop_rx.recv().await;
     }
 }
 
 impl Drop for TestServer {
     fn drop(&mut self) {
-        self.stop()
+        // calls in this Drop impl should be enough to shut down the server, system, and thread
+        // without needing to await anything
+
+        // signal server to stop
+        let _ = self.server.stop(true);
+
+        // signal system to stop
+        self.system.stop();
     }
 }
 

actix-http/CHANGES.md

@@ -3,39 +3,212 @@
 ## Unreleased - 2021-xx-xx
 
 
-## 3.0.0-beta.7 - 2021-06-17
-### Added
-* Alias `body::Body` as `body::AnyBody`. [#2215]
-* `BoxAnyBody`: a boxed message body with boxed errors. [#2183]
-* Re-export `http` crate's `Error` type as `error::HttpError`. [#2171]
-* Re-export `StatusCode`, `Method`, `Version` and `Uri` at the crate root. [#2171]
-* Re-export `ContentEncoding` and `ConnectionType` at the crate root. [#2171]
-* `Response::into_body` that consumes response and returns body type. [#2201]
-* `impl Default` for `Response`. [#2201]
-* Add zstd support for `ContentEncoding`. [#2244]
-
-### Changed
-* The `MessageBody` trait now has an associated `Error` type. [#2183]
-* All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
-* All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
-* Places in `Response` where `ResponseBody<B>` was received or returned now simply use `B`. [#2201]
-* `header` mod is now public. [#2171]
-* `uri` mod is now public. [#2171]
-* Update `language-tags` to `0.3`.
-* Reduce the level from `error` to `debug` for the log line that is emitted when a `500 Internal Server Error` is built using `HttpResponse::from_error`. [#2201]
-* `ResponseBuilder::message_body` now returns a `Result`. [#2201]
-* Remove `Unpin` bound on `ResponseBuilder::streaming`. [#2253]
-* `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
+## 3.0.0-beta.17 - 2021-12-27
+### Changes
+- `HeaderMap::get_all` now returns a `std::slice::Iter`. [#2527]
+- `Payload` inner fields are now named. [#2545]
+- `impl Stream` for `Payload` no longer requires the `Stream` variant be `Unpin`. [#2545]
+- `impl Future` for `h1::SendResponse` no longer requires the body type be `Unpin`. [#2545]
+- `impl Stream` for `encoding::Decoder` no longer requires the stream type be `Unpin`. [#2545]
+- Rename `PayloadStream` to `BoxedPayloadStream`. [#2545]
 
 ### Removed
-* Stop re-exporting `http` crate's `HeaderMap` types in addition to ours. [#2171]
-* Down-casting for `MessageBody` types. [#2183]
-* `error::Result` alias. [#2201]
-* Error field from `Response` and `Response::error`. [#2205]
-* `impl Future` for `Response`. [#2201]
-* `Response::take_body` and old `Response::into_body` method that casted body type. [#2201]
-* `InternalError` and all the error types it constructed. [#2215]
-* Conversion (`impl Into`) of `Response<Body>` and `ResponseBuilder` to `Error`. [#2215]
+- `h1::Payload::readany`. [#2545]
+
+[#2527]: https://github.com/actix/actix-web/pull/2527
+[#2545]: https://github.com/actix/actix-web/pull/2545
+
+
+## 3.0.0-beta.16 - 2021-12-17
+### Added
+- New method on `MessageBody` trait, `try_into_bytes`, with default implementation, for optimizations on body types that complete in exactly one poll. Replaces `is_complete_body` and `take_complete_body`. [#2522]
+
+### Changed
+- Rename trait `IntoHeaderPair => TryIntoHeaderPair`. [#2510]
+- Rename `TryIntoHeaderPair::{try_into_header_pair => try_into_pair}`. [#2510]
+- Rename trait `IntoHeaderValue => TryIntoHeaderValue`. [#2510]
+
+### Removed
+- `MessageBody::{is_complete_body,take_complete_body}`. [#2522]
+
+[#2510]: https://github.com/actix/actix-web/pull/2510
+[#2522]: https://github.com/actix/actix-web/pull/2522
+
+
+## 3.0.0-beta.15 - 2021-12-11
+### Added
+- Add timeout for canceling HTTP/2 server side connection handshake. Default to 5 seconds. [#2483]
+- HTTP/2 handshake timeout can be configured with `ServiceConfig::client_timeout`. [#2483]
+- `Response::map_into_boxed_body`. [#2468]
+- `body::EitherBody` enum. [#2468]
+- `body::None` struct. [#2468]
+- Impl `MessageBody` for `bytestring::ByteString`. [#2468]
+- `impl Clone for ws::HandshakeError`. [#2468]
+- `#[must_use]` for `ws::Codec` to prevent subtle bugs. [#1920]
+- `impl Default ` for `ws::Codec`. [#1920]
+- `header::QualityItem::{max, min}`. [#2486]
+- `header::Quality::{MAX, MIN}`. [#2486]
+- `impl Display` for `header::Quality`. [#2486]
+- Connection data set through the `on_connect_ext` callbacks is now accessible only from the new `Request::conn_data()` method. [#2491]
+- `Request::take_conn_data()`. [#2491]
+- `Request::take_req_data()`. [#2487]
+- `impl Clone` for `RequestHead`. [#2487]
+- New methods on `MessageBody` trait, `is_complete_body` and `take_complete_body`, both with default implementations, for optimizations on body types that are done in exactly one poll/chunk. [#2497]
+- New `boxed` method on `MessageBody` trait for wrapping body type. [#2520]
+
+### Changed
+- Rename `body::BoxBody::{from_body => new}`. [#2468]
+- Body type for `Responses` returned from `Response::{new, ok, etc...}` is now `BoxBody`. [#2468]
+- The `Error` associated type on `MessageBody` type now requires `impl Error` (or similar). [#2468]
+- Error types using in service builders now require `Into<Response<BoxBody>>`. [#2468]
+- `From` implementations on error types now return a `Response<BoxBody>`. [#2468]
+- `ResponseBuilder::body(B)` now returns `Response<EitherBody<B>>`. [#2468]
+- `ResponseBuilder::finish()` now returns `Response<EitherBody<()>>`. [#2468]
+
+### Removed
+- `ResponseBuilder::streaming`. [#2468]
+- `impl Future` for `ResponseBuilder`. [#2468]
+- Remove unnecessary `MessageBody` bound on types passed to `body::AnyBody::new`. [#2468]
+- Move `body::AnyBody` to `awc`. Replaced with `EitherBody` and `BoxBody`. [#2468]
+- `impl Copy` for `ws::Codec`. [#1920]
+- `header::qitem` helper. Replaced with `header::QualityItem::max`. [#2486]
+- `impl TryFrom<u16>` for `header::Quality`. [#2486]
+- `http` module. Most everything it contained is exported at the crate root. [#2488]
+
+[#2483]: https://github.com/actix/actix-web/pull/2483
+[#2468]: https://github.com/actix/actix-web/pull/2468
+[#1920]: https://github.com/actix/actix-web/pull/1920
+[#2486]: https://github.com/actix/actix-web/pull/2486
+[#2487]: https://github.com/actix/actix-web/pull/2487
+[#2488]: https://github.com/actix/actix-web/pull/2488
+[#2491]: https://github.com/actix/actix-web/pull/2491
+[#2497]: https://github.com/actix/actix-web/pull/2497
+[#2520]: https://github.com/actix/actix-web/pull/2520
+
+
+## 3.0.0-beta.14 - 2021-11-30
+### Changed
+- Guarantee ordering of `header::GetAll` iterator to be same as insertion order. [#2467]
+- Expose `header::map` module. [#2467]
+- Implement `ExactSizeIterator` and `FusedIterator` for all `HeaderMap` iterators. [#2470]
+- Update `actix-tls` to `3.0.0-rc.1`. [#2474]
+
+[#2467]: https://github.com/actix/actix-web/pull/2467
+[#2470]: https://github.com/actix/actix-web/pull/2470
+[#2474]: https://github.com/actix/actix-web/pull/2474
+
+
+## 3.0.0-beta.13 - 2021-11-22
+### Added
+- `body::AnyBody::empty` for quickly creating an empty body. [#2446]
+- `body::AnyBody::none` for quickly creating a "none" body. [#2456]
+- `impl Clone` for `body::AnyBody<S> where S: Clone`. [#2448]
+- `body::AnyBody::into_boxed` for quickly converting to a type-erased, boxed body type. [#2448]
+
+### Changed
+- Rename `body::AnyBody::{Message => Body}`. [#2446]
+- Rename `body::AnyBody::{from_message => new_boxed}`. [#2448]
+- Rename `body::AnyBody::{from_slice => copy_from_slice}`. [#2448]
+- Rename `body::{BoxAnyBody => BoxBody}`. [#2448]
+- Change representation of `AnyBody` to include a type parameter in `Body` variant. Defaults to `BoxBody`. [#2448]
+- `Encoder::response` now returns `AnyBody<Encoder<B>>`. [#2448]
+
+### Removed
+- `body::AnyBody::Empty`; an empty body can now only be represented as a zero-length `Bytes` variant. [#2446]
+- `body::BodySize::Empty`; an empty body can now only be represented as a `Sized(0)` variant. [#2446]
+- `EncoderError::Boxed`; it is no longer required. [#2446]
+- `body::ResponseBody`; is function is replaced by the new `body::AnyBody` enum. [#2446]
+
+[#2446]: https://github.com/actix/actix-web/pull/2446
+[#2448]: https://github.com/actix/actix-web/pull/2448
+[#2456]: https://github.com/actix/actix-web/pull/2456
+
+
+## 3.0.0-beta.12 - 2021-11-15
+### Changed
+- Update `actix-server` to `2.0.0-beta.9`. [#2442]
+
+### Removed
+- `client` module. [#2425]
+- `trust-dns` feature. [#2425]
+
+[#2425]: https://github.com/actix/actix-web/pull/2425
+[#2442]: https://github.com/actix/actix-web/pull/2442
+
+
+## 3.0.0-beta.11 - 2021-10-20
+### Changed
+- Updated rustls to v0.20. [#2414]
+- Minimum supported Rust version (MSRV) is now 1.52.
+
+[#2414]: https://github.com/actix/actix-web/pull/2414
+
+
+## 3.0.0-beta.10 - 2021-09-09
+### Changed
+- `ContentEncoding` is now marked `#[non_exhaustive]`. [#2377]
+- Minimum supported Rust version (MSRV) is now 1.51.
+
+### Fixed
+- Remove slice creation pointing to potential uninitialized data on h1 encoder. [#2364]
+- Remove `Into<Error>` bound on `Encoder` body types. [#2375]
+- Fix quality parse error in Accept-Encoding header. [#2344]
+
+[#2364]: https://github.com/actix/actix-web/pull/2364
+[#2375]: https://github.com/actix/actix-web/pull/2375
+[#2344]: https://github.com/actix/actix-web/pull/2344
+[#2377]: https://github.com/actix/actix-web/pull/2377
+
+
+## 3.0.0-beta.9 - 2021-08-09
+### Fixed
+- Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
+
+
+## 3.0.0-beta.8 - 2021-06-26
+### Changed
+- Change compression algorithm features flags. [#2250]
+
+### Removed
+- `downcast` and `downcast_get_type_id` macros. [#2291]
+
+[#2291]: https://github.com/actix/actix-web/pull/2291
+[#2250]: https://github.com/actix/actix-web/pull/2250
+
+
+## 3.0.0-beta.7 - 2021-06-17
+### Added
+- Alias `body::Body` as `body::AnyBody`. [#2215]
+- `BoxAnyBody`: a boxed message body with boxed errors. [#2183]
+- Re-export `http` crate's `Error` type as `error::HttpError`. [#2171]
+- Re-export `StatusCode`, `Method`, `Version` and `Uri` at the crate root. [#2171]
+- Re-export `ContentEncoding` and `ConnectionType` at the crate root. [#2171]
+- `Response::into_body` that consumes response and returns body type. [#2201]
+- `impl Default` for `Response`. [#2201]
+- Add zstd support for `ContentEncoding`. [#2244]
+
+### Changed
+- The `MessageBody` trait now has an associated `Error` type. [#2183]
+- All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
+- All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
+- Places in `Response` where `ResponseBody<B>` was received or returned now simply use `B`. [#2201]
+- `header` mod is now public. [#2171]
+- `uri` mod is now public. [#2171]
+- Update `language-tags` to `0.3`.
+- Reduce the level from `error` to `debug` for the log line that is emitted when a `500 Internal Server Error` is built using `HttpResponse::from_error`. [#2201]
+- `ResponseBuilder::message_body` now returns a `Result`. [#2201]
+- Remove `Unpin` bound on `ResponseBuilder::streaming`. [#2253]
+- `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
+
+### Removed
+- Stop re-exporting `http` crate's `HeaderMap` types in addition to ours. [#2171]
+- Down-casting for `MessageBody` types. [#2183]
+- `error::Result` alias. [#2201]
+- Error field from `Response` and `Response::error`. [#2205]
+- `impl Future` for `Response`. [#2201]
+- `Response::take_body` and old `Response::into_body` method that casted body type. [#2201]
+- `InternalError` and all the error types it constructed. [#2215]
+- Conversion (`impl Into`) of `Response<Body>` and `ResponseBuilder` to `Error`. [#2215]
 
 [#2171]: https://github.com/actix/actix-web/pull/2171
 [#2183]: https://github.com/actix/actix-web/pull/2183
@@ -50,27 +223,27 @@
 
 ## 3.0.0-beta.6 - 2021-04-17
 ### Added
-* `impl<T: MessageBody> MessageBody for Pin<Box<T>>`. [#2152]
-* `Response::{ok, bad_request, not_found, internal_server_error}`. [#2159]
-* Helper `body::to_bytes` for async collecting message body into Bytes. [#2158]
+- `impl<T: MessageBody> MessageBody for Pin<Box<T>>`. [#2152]
+- `Response::{ok, bad_request, not_found, internal_server_error}`. [#2159]
+- Helper `body::to_bytes` for async collecting message body into Bytes. [#2158]
 
 ### Changes
-* The type parameter of `Response` no longer has a default. [#2152]
-* The `Message` variant of `body::Body` is now `Pin<Box<dyn MessageBody>>`. [#2152]
-* `BodyStream` and `SizedStream` are no longer restricted to Unpin types. [#2152]
-* Error enum types are marked `#[non_exhaustive]`. [#2161]
+- The type parameter of `Response` no longer has a default. [#2152]
+- The `Message` variant of `body::Body` is now `Pin<Box<dyn MessageBody>>`. [#2152]
+- `BodyStream` and `SizedStream` are no longer restricted to Unpin types. [#2152]
+- Error enum types are marked `#[non_exhaustive]`. [#2161]
 
 ### Removed
-* `cookies` feature flag. [#2065]
-* Top-level `cookies` mod (re-export). [#2065]
-* `HttpMessage` trait loses the `cookies` and `cookie` methods. [#2065]
-* `impl ResponseError for CookieParseError`. [#2065]
-* Deprecated methods on `ResponseBuilder`: `if_true`, `if_some`. [#2148]
-* `ResponseBuilder::json`. [#2148]
-* `ResponseBuilder::{set_header, header}`. [#2148]
-* `impl From<serde_json::Value> for Body`. [#2148]
-* `Response::build_from`. [#2159]
-* Most of the status code builders on `Response`. [#2159]
+- `cookies` feature flag. [#2065]
+- Top-level `cookies` mod (re-export). [#2065]
+- `HttpMessage` trait loses the `cookies` and `cookie` methods. [#2065]
+- `impl ResponseError for CookieParseError`. [#2065]
+- Deprecated methods on `ResponseBuilder`: `if_true`, `if_some`. [#2148]
+- `ResponseBuilder::json`. [#2148]
+- `ResponseBuilder::{set_header, header}`. [#2148]
+- `impl From<serde_json::Value> for Body`. [#2148]
+- `Response::build_from`. [#2159]
+- Most of the status code builders on `Response`. [#2159]
 
 [#2065]: https://github.com/actix/actix-web/pull/2065
 [#2148]: https://github.com/actix/actix-web/pull/2148
@@ -82,16 +255,16 @@
 
 ## 3.0.0-beta.5 - 2021-04-02
 ### Added
-* `client::Connector::handshake_timeout` method for customizing TLS connection handshake timeout. [#2081]
-* `client::ConnectorService` as `client::Connector::finish` method's return type [#2081]
-* `client::ConnectionIo` trait alias [#2081]
+- `client::Connector::handshake_timeout` method for customizing TLS connection handshake timeout. [#2081]
+- `client::ConnectorService` as `client::Connector::finish` method's return type [#2081]
+- `client::ConnectionIo` trait alias [#2081]
 
 ### Changed
-* `client::Connector` type now only have one generic type for `actix_service::Service`. [#2063]
+- `client::Connector` type now only have one generic type for `actix_service::Service`. [#2063]
 
 ### Removed
-* Common typed HTTP headers were moved to actix-web. [2094]
-* `ResponseError` impl for `actix_utils::timeout::TimeoutError`. [#2127]
+- Common typed HTTP headers were moved to actix-web. [2094]
+- `ResponseError` impl for `actix_utils::timeout::TimeoutError`. [#2127]
 
 [#2063]: https://github.com/actix/actix-web/pull/2063
 [#2081]: https://github.com/actix/actix-web/pull/2081
@@ -101,13 +274,13 @@
 
 ## 3.0.0-beta.4 - 2021-03-08
 ### Changed
-* Feature `cookies` is now optional and disabled by default. [#1981]
-* `ws::hash_key` now returns array. [#2035]
-* `ResponseBuilder::json` now takes `impl Serialize`. [#2052]
+- Feature `cookies` is now optional and disabled by default. [#1981]
+- `ws::hash_key` now returns array. [#2035]
+- `ResponseBuilder::json` now takes `impl Serialize`. [#2052]
 
 ### Removed
-* Re-export of `futures_channel::oneshot::Canceled` is removed from `error` mod. [#1994]
-* `ResponseError` impl for `futures_channel::oneshot::Canceled` is removed. [#1994]
+- Re-export of `futures_channel::oneshot::Canceled` is removed from `error` mod. [#1994]
+- `ResponseError` impl for `futures_channel::oneshot::Canceled` is removed. [#1994]
 
 [#1981]: https://github.com/actix/actix-web/pull/1981
 [#1994]: https://github.com/actix/actix-web/pull/1994
@@ -116,48 +289,48 @@
 
 
 ## 3.0.0-beta.3 - 2021-02-10
-* No notable changes.
+- No notable changes.
 
 
 ## 3.0.0-beta.2 - 2021-02-10
 ### Added
-* `IntoHeaderPair` trait that allows using typed and untyped headers in the same methods. [#1869]
-* `ResponseBuilder::insert_header` method which allows using typed headers. [#1869]
-* `ResponseBuilder::append_header` method which allows using typed headers. [#1869]
-* `TestRequest::insert_header` method which allows using typed headers. [#1869]
-* `ContentEncoding` implements all necessary header traits. [#1912]
-* `HeaderMap::len_keys` has the behavior of the old `len` method. [#1964]
-* `HeaderMap::drain` as an efficient draining iterator. [#1964]
-* Implement `IntoIterator` for owned `HeaderMap`. [#1964]
-* `trust-dns` optional feature to enable `trust-dns-resolver` as client dns resolver. [#1969]
+- `TryIntoHeaderPair` trait that allows using typed and untyped headers in the same methods. [#1869]
+- `ResponseBuilder::insert_header` method which allows using typed headers. [#1869]
+- `ResponseBuilder::append_header` method which allows using typed headers. [#1869]
+- `TestRequest::insert_header` method which allows using typed headers. [#1869]
+- `ContentEncoding` implements all necessary header traits. [#1912]
+- `HeaderMap::len_keys` has the behavior of the old `len` method. [#1964]
+- `HeaderMap::drain` as an efficient draining iterator. [#1964]
+- Implement `IntoIterator` for owned `HeaderMap`. [#1964]
+- `trust-dns` optional feature to enable `trust-dns-resolver` as client dns resolver. [#1969]
 
 ### Changed
-* `ResponseBuilder::content_type` now takes an `impl IntoHeaderValue` to support using typed
+- `ResponseBuilder::content_type` now takes an `impl TryIntoHeaderValue` to support using typed
   `mime` types. [#1894]
-* Renamed `IntoHeaderValue::{try_into => try_into_value}` to avoid ambiguity with std
+- Renamed `TryIntoHeaderValue::{try_into => try_into_value}` to avoid ambiguity with std
   `TryInto` trait. [#1894]
-* `Extensions::insert` returns Option of replaced item. [#1904]
-* Remove `HttpResponseBuilder::json2()`. [#1903]
-* Enable `HttpResponseBuilder::json()` to receive data by value and reference. [#1903]
-* `client::error::ConnectError` Resolver variant contains `Box<dyn std::error::Error>` type. [#1905]
-* `client::ConnectorConfig` default timeout changed to 5 seconds. [#1905]
-* Simplify `BlockingError` type to a unit struct. It's now only triggered when blocking thread pool
+- `Extensions::insert` returns Option of replaced item. [#1904]
+- Remove `HttpResponseBuilder::json2()`. [#1903]
+- Enable `HttpResponseBuilder::json()` to receive data by value and reference. [#1903]
+- `client::error::ConnectError` Resolver variant contains `Box<dyn std::error::Error>` type. [#1905]
+- `client::ConnectorConfig` default timeout changed to 5 seconds. [#1905]
+- Simplify `BlockingError` type to a unit struct. It's now only triggered when blocking thread pool
   is dead. [#1957]
-* `HeaderMap::len` now returns number of values instead of number of keys. [#1964]
-* `HeaderMap::insert` now returns iterator of removed values. [#1964]
-* `HeaderMap::remove` now returns iterator of removed values. [#1964]
+- `HeaderMap::len` now returns number of values instead of number of keys. [#1964]
+- `HeaderMap::insert` now returns iterator of removed values. [#1964]
+- `HeaderMap::remove` now returns iterator of removed values. [#1964]
 
 ### Removed
-* `ResponseBuilder::set`; use `ResponseBuilder::insert_header`. [#1869]
-* `ResponseBuilder::set_header`; use `ResponseBuilder::insert_header`. [#1869]
-* `ResponseBuilder::header`; use `ResponseBuilder::append_header`. [#1869]
-* `TestRequest::with_hdr`; use `TestRequest::default().insert_header()`. [#1869]
-* `TestRequest::with_header`; use `TestRequest::default().insert_header()`. [#1869]
-* `actors` optional feature. [#1969]
-* `ResponseError` impl for `actix::MailboxError`. [#1969]
+- `ResponseBuilder::set`; use `ResponseBuilder::insert_header`. [#1869]
+- `ResponseBuilder::set_header`; use `ResponseBuilder::insert_header`. [#1869]
+- `ResponseBuilder::header`; use `ResponseBuilder::append_header`. [#1869]
+- `TestRequest::with_hdr`; use `TestRequest::default().insert_header()`. [#1869]
+- `TestRequest::with_header`; use `TestRequest::default().insert_header()`. [#1869]
+- `actors` optional feature. [#1969]
+- `ResponseError` impl for `actix::MailboxError`. [#1969]
 
 ### Documentation
-* Vastly improve docs and add examples for `HeaderMap`. [#1964]
+- Vastly improve docs and add examples for `HeaderMap`. [#1964]
 
 [#1869]: https://github.com/actix/actix-web/pull/1869
 [#1894]: https://github.com/actix/actix-web/pull/1894
@@ -172,24 +345,24 @@
 
 ## 3.0.0-beta.1 - 2021-01-07
 ### Added
-* Add `Http3` to `Protocol` enum for future compatibility and also mark `#[non_exhaustive]`.
+- Add `Http3` to `Protocol` enum for future compatibility and also mark `#[non_exhaustive]`.
 
 ### Changed
-* Update `actix-*` dependencies to tokio `1.0` based versions. [#1813]
-* Bumped `rand` to `0.8`.
-* Update `bytes` to `1.0`. [#1813]
-* Update `h2` to `0.3`. [#1813]
-* The `ws::Message::Text` enum variant now contains a `bytestring::ByteString`. [#1864]
+- Update `actix-*` dependencies to tokio `1.0` based versions. [#1813]
+- Bumped `rand` to `0.8`.
+- Update `bytes` to `1.0`. [#1813]
+- Update `h2` to `0.3`. [#1813]
+- The `ws::Message::Text` enum variant now contains a `bytestring::ByteString`. [#1864]
 
 ### Removed
-* Deprecated `on_connect` methods have been removed. Prefer the new
+- Deprecated `on_connect` methods have been removed. Prefer the new
   `on_connect_ext` technique. [#1857]
-* Remove `ResponseError` impl for `actix::actors::resolver::ResolverError`
+- Remove `ResponseError` impl for `actix::actors::resolver::ResolverError`
   due to deprecate of resolver actor. [#1813]
-* Remove `ConnectError::SslHandshakeError` and re-export of `HandshakeError`.
+- Remove `ConnectError::SslHandshakeError` and re-export of `HandshakeError`.
   due to the removal of this type from `tokio-openssl` crate. openssl handshake 
   error would return as `ConnectError::SslError`. [#1813]
-* Remove `actix-threadpool` dependency. Use `actix_rt::task::spawn_blocking`.
+- Remove `actix-threadpool` dependency. Use `actix_rt::task::spawn_blocking`.
   Due to this change `actix_threadpool::BlockingError` type is moved into 
   `actix_http::error` module. [#1878]
 
@@ -199,17 +372,22 @@
 [#1878]: https://github.com/actix/actix-web/pull/1878
 
 
+## 2.2.1 - 2021-08-09
+### Fixed
+- Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
+
+
 ## 2.2.0 - 2020-11-25
 ### Added
-* HttpResponse builders for 1xx status codes. [#1768]
-* `Accept::mime_precedence` and `Accept::mime_preference`. [#1793]
-* `TryFrom<u16>` and `TryFrom<f32>` for `http::header::Quality`. [#1797]
+- HttpResponse builders for 1xx status codes. [#1768]
+- `Accept::mime_precedence` and `Accept::mime_preference`. [#1793]
+- `TryFrom<u16>` and `TryFrom<f32>` for `http::header::Quality`. [#1797]
 
 ### Fixed
-* Started dropping `transfer-encoding: chunked` and `Content-Length` for 1XX and 204 responses. [#1767]
+- Started dropping `transfer-encoding: chunked` and `Content-Length` for 1XX and 204 responses. [#1767]
 
 ### Changed
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
+- Upgrade `serde_urlencoded` to `0.7`. [#1773]
 
 [#1773]: https://github.com/actix/actix-web/pull/1773
 [#1767]: https://github.com/actix/actix-web/pull/1767
@@ -220,12 +398,12 @@
 
 ## 2.1.0 - 2020-10-30
 ### Added
-* Added more flexible `on_connect_ext` methods for on-connect handling. [#1754]
+- Added more flexible `on_connect_ext` methods for on-connect handling. [#1754]
 
 ### Changed
-* Upgrade `base64` to `0.13`. [#1744]
-* Upgrade `pin-project` to `1.0`. [#1733]
-* Deprecate `ResponseBuilder::{if_some, if_true}`. [#1760]
+- Upgrade `base64` to `0.13`. [#1744]
+- Upgrade `pin-project` to `1.0`. [#1733]
+- Deprecate `ResponseBuilder::{if_some, if_true}`. [#1760]
 
 [#1760]: https://github.com/actix/actix-web/pull/1760
 [#1754]: https://github.com/actix/actix-web/pull/1754
@@ -234,28 +412,28 @@
 
 
 ## 2.0.0 - 2020-09-11
-* No significant changes from `2.0.0-beta.4`.
+- 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.
+- 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]
+- 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]
+- Potential UB in h1 decoder using uninitialized memory. [#1614]
 
 ### Changed
-* Fix illegal chunked encoding. [#1615]
+- Fix illegal chunked encoding. [#1615]
 
 [#1614]: https://github.com/actix/actix-web/pull/1614
 [#1615]: https://github.com/actix/actix-web/pull/1615
@@ -263,10 +441,10 @@
 
 ## 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.
+- 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
@@ -275,15 +453,15 @@
 
 ## 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
+- 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
+- `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
   `u64` instead of a `usize`.
-* Update `base64` dependency to 0.12
+- Update `base64` dependency to 0.12
 
 ### Fixed
-* Support parsing of `SameSite=None` [#1503]
+- Support parsing of `SameSite=None` [#1503]
 
 [#1439]: https://github.com/actix/actix-web/pull/1439
 [#1503]: https://github.com/actix/actix-web/pull/1503
@@ -291,13 +469,13 @@
 
 ## 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
+- 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
+- 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
@@ -306,12 +484,12 @@
 
 ## 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
+- 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
+- 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]
+- 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
@@ -319,61 +497,61 @@
 
 ## 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
+- 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.
+- MessageBody is not implemented for &'static [u8] anymore.
 
 ### Fixed
-* Allow `SameSite=None` cookies to be sent in a response.
+- Allow `SameSite=None` cookies to be sent in a response.
 
 
 ## 1.0.1 - 2019-12-20
 ### Fixed
-* Poll upgrade service's readiness from HTTP service handlers
-* Replace brotli with brotli2 #1224
+- Poll upgrade service's readiness from HTTP service handlers
+- Replace brotli with brotli2 #1224
 
 
 ## 1.0.0 - 2019-12-13
 ### Added
-* Add websockets continuation frame support
+- Add websockets continuation frame support
 
 ### Changed
-* Replace `flate2-xxx` features with `compress`
+- Replace `flate2-xxx` features with `compress`
 
 
 ## 1.0.0-alpha.5 - 2019-12-09
 ### Fixed
-* Check `Upgrade` service readiness before calling it
-* Fix buffer remaining capacity calculation
+- Check `Upgrade` service readiness before calling it
+- Fix buffer remaining capacity calculation
 
 ### Changed
-* Websockets: Ping and Pong should have binary data #1049
+- Websockets: Ping and Pong should have binary data #1049
 
 
 ## 1.0.0-alpha.4 - 2019-12-08
 ### Added
-* Add impl ResponseBuilder for Error
+- Add impl ResponseBuilder for Error
 
 ### Changed
-* Use rust based brotli compression library
+- Use rust based brotli compression library
 
 ## 1.0.0-alpha.3 - 2019-12-07
 ### Changed
-* Migrate to tokio 0.2
-* Migrate to `std::future`
+- Migrate to tokio 0.2
+- Migrate to `std::future`
 
 
 ## 0.2.11 - 2019-11-06
 ### Added
-* Add support for serde_json::Value to be passed as argument to ResponseBuilder.body()
-* Add an additional `filename*` param in the `Content-Disposition` header of
+- Add support for serde_json::Value to be passed as argument to ResponseBuilder.body()
+- Add an additional `filename*` param in the `Content-Disposition` header of
   `actix_files::NamedFile` to be more compatible. (#1151)
-* Allow to use `std::convert::Infallible` as `actix_http::error::Error`
+- Allow to use `std::convert::Infallible` as `actix_http::error::Error`
 
 ### Fixed
-* To be compatible with non-English error responses, `ResponseError` rendered with `text/plain;
+- To be compatible with non-English error responses, `ResponseError` rendered with `text/plain;
   charset=utf-8` header [#1118]
 
 [#1878]: https://github.com/actix/actix-web/pull/1878
@@ -381,169 +559,169 @@
 
 ## 0.2.10 - 2019-09-11
 ### Added
-* Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests
+- Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests
   with `RequestHead`
 
 ### Fixed
-* h2 will use error response #1080
-* on_connect result isn't added to request extensions for http2 requests #1009
+- h2 will use error response #1080
+- on_connect result isn't added to request extensions for http2 requests #1009
 
 
 ## 0.2.9 - 2019-08-13
 ### Changed
-* Dropped the `byteorder`-dependency in favor of `stdlib`-implementation
-* Update percent-encoding to 2.1
-* Update serde_urlencoded to 0.6.1
+- Dropped the `byteorder`-dependency in favor of `stdlib`-implementation
+- Update percent-encoding to 2.1
+- Update serde_urlencoded to 0.6.1
 
 ### Fixed
-* Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
+- Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
 
 
 ## 0.2.8 - 2019-08-01
 ### Added
-* Add `rustls` support
-* Add `Clone` impl for `HeaderMap`
+- Add `rustls` support
+- Add `Clone` impl for `HeaderMap`
 
 ### Fixed
-* awc client panic #1016
-* Invalid response with compression middleware enabled, but compression-related features
+- awc client panic #1016
+- Invalid response with compression middleware enabled, but compression-related features
   disabled #997
 
 
 ## 0.2.7 - 2019-07-18
 ### Added
-* Add support for downcasting response errors #986
+- Add support for downcasting response errors #986
 
 
 ## 0.2.6 - 2019-07-17
 ### Changed
-* Replace `ClonableService` with local copy
-* Upgrade `rand` dependency version to 0.7
+- Replace `ClonableService` with local copy
+- Upgrade `rand` dependency version to 0.7
 
 
 ## 0.2.5 - 2019-06-28
 ### Added
-* Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
+- Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
 
 ### Changed
-* Use `encoding_rs` crate instead of unmaintained `encoding` crate
-* Add `Copy` and `Clone` impls for `ws::Codec`
+- Use `encoding_rs` crate instead of unmaintained `encoding` crate
+- Add `Copy` and `Clone` impls for `ws::Codec`
 
 
 ## 0.2.4 - 2019-06-16
 ### Fixed
-* Do not compress NoContent (204) responses #918
+- Do not compress NoContent (204) responses #918
 
 
 ## 0.2.3 - 2019-06-02
 ### Added
-* Debug impl for ResponseBuilder
-* From SizedStream and BodyStream for Body
+- Debug impl for ResponseBuilder
+- From SizedStream and BodyStream for Body
 
 ### Changed
-* SizedStream uses u64
+- SizedStream uses u64
 
 
 ## 0.2.2 - 2019-05-29
 ### Fixed
-* Parse incoming stream before closing stream on disconnect #868
+- Parse incoming stream before closing stream on disconnect #868
 
 
 ## 0.2.1 - 2019-05-25
 ### Fixed
-* Handle socket read disconnect
+- Handle socket read disconnect
 
 
 ## 0.2.0 - 2019-05-12
 ### Changed
-* Update actix-service to 0.4
-* Expect and upgrade services accept `ServerConfig` config.
+- Update actix-service to 0.4
+- Expect and upgrade services accept `ServerConfig` config.
 
 ### Deleted
-* `OneRequest` service
+- `OneRequest` service
 
 
 ## 0.1.5 - 2019-05-04
 ### Fixed
-* Clean up response extensions in response pool #817
+- Clean up response extensions in response pool #817
 
 
 ## 0.1.4 - 2019-04-24
 ### Added
-* Allow to render h1 request headers in `Camel-Case`
+- Allow to render h1 request headers in `Camel-Case`
 
 ### Fixed
-* Read until eof for http/1.0 responses #771
+- Read until eof for http/1.0 responses #771
 
 
 ## 0.1.3 - 2019-04-23
 ### Fixed
-* Fix http client pool management
-* Fix http client wait queue management #794
+- Fix http client pool management
+- Fix http client wait queue management #794
 
 
 ## 0.1.2 - 2019-04-23
 ### Fixed
-* Fix BorrowMutError panic in client connector #793
+- Fix BorrowMutError panic in client connector #793
 
 
 ## 0.1.1 - 2019-04-19
 ### Changed
-* Cookie::max_age() accepts value in seconds
-* Cookie::max_age_time() accepts value in time::Duration
-* Allow to specify server address for client connector
+- Cookie::max_age() accepts value in seconds
+- Cookie::max_age_time() accepts value in time::Duration
+- Allow to specify server address for client connector
 
 
 ## 0.1.0 - 2019-04-16
 ### Added
-* Expose peer addr via `Request::peer_addr()` and `RequestHead::peer_addr`
+- Expose peer addr via `Request::peer_addr()` and `RequestHead::peer_addr`
 
 ### Changed
-* `actix_http::encoding` always available
-* use trust-dns-resolver 0.11.0
+- `actix_http::encoding` always available
+- use trust-dns-resolver 0.11.0
 
 
 ## 0.1.0-alpha.5 - 2019-04-12
 ### Added
-* Allow to use custom service for upgrade requests
-* Added `h1::SendResponse` future.
+- Allow to use custom service for upgrade requests
+- Added `h1::SendResponse` future.
 
 ### Changed
-* MessageBody::length() renamed to MessageBody::size() for consistency
-* ws handshake verification functions take RequestHead instead of Request
+- MessageBody::length() renamed to MessageBody::size() for consistency
+- ws handshake verification functions take RequestHead instead of Request
 
 
 ## 0.1.0-alpha.4 - 2019-04-08
 ### Added
-* Allow to use custom `Expect` handler
-* Add minimal `std::error::Error` impl for `Error`
+- Allow to use custom `Expect` handler
+- Add minimal `std::error::Error` impl for `Error`
 
 ### Changed
-* Export IntoHeaderValue
-* Render error and return as response body
-* Use thread pool for response body compression
+- Export IntoHeaderValue
+- Render error and return as response body
+- Use thread pool for response body compression
 
 ### Deleted
-* Removed PayloadBuffer
+- Removed PayloadBuffer
 
 
 ## 0.1.0-alpha.3 - 2019-04-02
 ### Added
-* Warn when an unsealed private cookie isn't valid UTF-8
+- Warn when an unsealed private cookie isn't valid UTF-8
 
 ### Fixed
-* Rust 1.31.0 compatibility
-* Preallocate read buffer for h1 codec
-* Detect socket disconnection during protocol selection
+- Rust 1.31.0 compatibility
+- Preallocate read buffer for h1 codec
+- Detect socket disconnection during protocol selection
 
 
 ## 0.1.0-alpha.2 - 2019-03-29
 ### Added
-* Added ws::Message::Nop, no-op websockets message
+- Added ws::Message::Nop, no-op websockets message
 
 ### Changed
-* Do not use thread pool for decompression if chunk size is smaller than 2048.
+- Do not use thread pool for decompression if chunk size is smaller than 2048.
 
 
 ## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl
+- Initial impl

actix-http/Cargo.toml

@@ -1,22 +1,23 @@
 [package]
 name = "actix-http"
-version = "3.0.0-beta.7"
+version = "3.0.0-beta.17"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "HTTP primitives for the Actix ecosystem"
-readme = "README.md"
 keywords = ["actix", "http", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-http/"
-categories = ["network-programming", "asynchronous",
-              "web-programming::http-server",
-              "web-programming::websocket"]
+categories = [
+    "network-programming",
+    "asynchronous",
+    "web-programming::http-server",
+    "web-programming::websocket",
+]
 license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
 # features that docs.rs will build with
-features = ["openssl", "rustls", "compress"]
+features = ["openssl", "rustls", "compress-brotli", "compress-gzip", "compress-zstd"]
 
 [lib]
 name = "actix_http"
@@ -26,23 +27,25 @@ path = "src/lib.rs"
 default = []
 
 # openssl
-openssl = ["actix-tls/openssl"]
+openssl = ["actix-tls/accept", "actix-tls/openssl"]
 
 # rustls support
-rustls = ["actix-tls/rustls"]
+rustls = ["actix-tls/accept", "actix-tls/rustls"]
 
 # enable compression support
-compress = ["flate2", "brotli2", "zstd"]
+compress-brotli = ["brotli2", "__compress"]
+compress-gzip = ["flate2", "__compress"]
+compress-zstd = ["zstd", "__compress"]
 
-# trust-dns as client dns resolver
-trust-dns = ["trust-dns-resolver"]
+# Internal (PRIVATE!) features used to aid testing and cheking feature status.
+# Don't rely on these whatsoever. They may disappear at anytime.
+__compress = []
 
 [dependencies]
 actix-service = "2.0.0"
-actix-codec = "0.4.0"
+actix-codec = "0.4.1"
 actix-utils = "3.0.0"
-actix-rt = "2.2"
-actix-tls = { version = "3.0.0-beta.5", features = ["accept", "connect"] }
+actix-rt = { version = "2.2", default-features = false }
 
 ahash = "0.7"
 base64 = "0.13"
@@ -52,47 +55,48 @@ bytestring = "1"
 derive_more = "0.99.5"
 encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-futures-util = { version = "0.3.7", default-features = false, features = ["alloc", "sink"] }
-h2 = "0.3.1"
-http = "0.2.2"
-httparse = "1.3"
-itoa = "0.4"
+h2 = "0.3.9"
+http = "0.2.5"
+httparse = "1.5.1"
+httpdate = "1.0.1"
+itoa = "1"
 language-tags = "0.3"
 local-channel = "0.1"
-once_cell = "1.5"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
-pin-project = "1.0.0"
 pin-project-lite = "0.2"
 rand = "0.8"
-regex = "1.3"
-serde = "1.0"
-sha-1 = "0.9"
-smallvec = "1.6"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
-tokio = { version = "1.2", features = ["sync"] }
+sha-1 = "0.10"
+smallvec = "1.6.1"
+
+# tls
+actix-tls = { version = "3.0.0", default-features = false, optional = true }
 
 # compression
 brotli2 = { version="0.3.2", optional = true }
 flate2 = { version = "1.0.13", optional = true }
-zstd = { version = "0.7", optional = true }
-
-trust-dns-resolver = { version = "0.20.0", optional = true }
+zstd = { version = "0.9", optional = true }
 
 [dev-dependencies]
-actix-server = "2.0.0-beta.3"
-actix-http-test = { version = "3.0.0-beta.4", features = ["openssl"] }
-actix-tls = { version = "3.0.0-beta.5", features = ["openssl"] }
+actix-http-test = { version = "3.0.0-beta.10", features = ["openssl"] }
+actix-server = "2.0.0-rc.2"
+actix-tls = { version = "3.0.0", features = ["openssl"] }
+actix-web = "4.0.0-beta.17"
+
 async-stream = "0.3"
 criterion = { version = "0.3", features = ["html_reports"] }
-env_logger = "0.8"
+env_logger = "0.9"
+futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
 rcgen = "0.8"
+regex = "1.3"
+rustls-pemfile = "0.2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-tls-openssl = { version = "0.10", package = "openssl" }
-tls-rustls = { version = "0.19", package = "rustls" }
-webpki = { version = "0.21.0" }
+static_assertions = "1"
+tls-openssl = { package = "openssl", version = "0.10.9" }
+tls-rustls = { package = "rustls", version = "0.20.0" }
+tokio = { version = "1.8.4", features = ["net", "rt", "macros"] }
 
 [[example]]
 name = "ws"
@@ -109,3 +113,7 @@ harness = false
 [[bench]]
 name = "uninit-headers"
 harness = false
+
+[[bench]]
+name = "quality-value"
+harness = false

actix-http/README.md

@@ -3,19 +3,18 @@
 > HTTP primitives for the Actix ecosystem.
 
 [![crates.io](https://img.shields.io/crates/v/actix-http?label=latest)](https://crates.io/crates/actix-http)
-[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.7)](https://docs.rs/actix-http/3.0.0-beta.7)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.17)](https://docs.rs/actix-http/3.0.0-beta.17)
+[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.7/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.7)
+[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.17/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.17)
 [![Download](https://img.shields.io/crates/d/actix-http.svg)](https://crates.io/crates/actix-http)
-[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-http)
-- [Chat on Gitter](https://gitter.im/actix/actix-web)
-- Minimum Supported Rust Version (MSRV): 1.46.0
+- Minimum Supported Rust Version (MSRV): 1.52
 
 ## Example
 
@@ -55,8 +54,8 @@ async fn main() -> io::Result<()> {
 
 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.
 

actix-http/benches/quality-value.rs

@@ -0,0 +1,90 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+const CODES: &[u16] = &[0, 1000, 201, 800, 550];
+
+fn bench_quality_display_impls(c: &mut Criterion) {
+    let mut group = c.benchmark_group("quality value display impls");
+
+    for i in CODES.iter() {
+        group.bench_with_input(BenchmarkId::new("New (fast?)", i), i, |b, &i| {
+            b.iter(|| _new::Quality(i).to_string())
+        });
+
+        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
+            b.iter(|| _naive::Quality(i).to_string())
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_quality_display_impls);
+criterion_main!(benches);
+
+mod _new {
+    use std::fmt;
+
+    pub struct Quality(pub(crate) u16);
+
+    impl fmt::Display for Quality {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            match self.0 {
+                0 => f.write_str("0"),
+                1000 => f.write_str("1"),
+
+                // some number in the range 1–999
+                x => {
+                    f.write_str("0.")?;
+
+                    // this implementation avoids string allocation otherwise required
+                    // for `.trim_end_matches('0')`
+
+                    if x < 10 {
+                        f.write_str("00")?;
+                        // 0 is handled so it's not possible to have a trailing 0, we can just return
+                        itoa::fmt(f, x)
+                    } else if x < 100 {
+                        f.write_str("0")?;
+                        if x % 10 == 0 {
+                            // trailing 0, divide by 10 and write
+                            itoa::fmt(f, x / 10)
+                        } else {
+                            itoa::fmt(f, x)
+                        }
+                    } else {
+                        // x is in range 101–999
+
+                        if x % 100 == 0 {
+                            // two trailing 0s, divide by 100 and write
+                            itoa::fmt(f, x / 100)
+                        } else if x % 10 == 0 {
+                            // one trailing 0, divide by 10 and write
+                            itoa::fmt(f, x / 10)
+                        } else {
+                            itoa::fmt(f, x)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+mod _naive {
+    use std::fmt;
+
+    pub struct Quality(pub(crate) u16);
+
+    impl fmt::Display for Quality {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            match self.0 {
+                0 => f.write_str("0"),
+                1000 => f.write_str("1"),
+
+                x => {
+                    write!(f, "{}", format!("{:03}", x).trim_end_matches('0'))
+                }
+            }
+        }
+    }
+}

actix-http/benches/status-line.rs

@@ -189,11 +189,7 @@ mod _original {
         n /= 100;
         curr -= 2;
         unsafe {
-            ptr::copy_nonoverlapping(
-                lut_ptr.offset(d1 as isize),
-                buf_ptr.offset(curr),
-                2,
-            );
+            ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
         }
 
         // decode last 1 or 2 chars
@@ -206,11 +202,7 @@ mod _original {
             let d1 = n << 1;
             curr -= 2;
             unsafe {
-                ptr::copy_nonoverlapping(
-                    lut_ptr.offset(d1 as isize),
-                    buf_ptr.offset(curr),
-                    2,
-                );
+                ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
             }
         }
 

actix-http/benches/uninit-headers.rs

@@ -54,15 +54,10 @@ const EMPTY_HEADER_INDEX: HeaderIndex = HeaderIndex {
     value: (0, 0),
 };
 
-const EMPTY_HEADER_INDEX_ARRAY: [HeaderIndex; MAX_HEADERS] =
-    [EMPTY_HEADER_INDEX; MAX_HEADERS];
+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],
-    ) {
+    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;
@@ -78,12 +73,12 @@ impl HeaderIndex {
 // test cases taken from:
 // https://github.com/seanmonstar/httparse/blob/master/benches/parse.rs
 
-const REQ_SHORT: &'static [u8] = b"\
+const REQ_SHORT: &[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"\
+const REQ: &[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\
@@ -119,6 +114,8 @@ mod _original {
     use std::mem::MaybeUninit;
 
     pub fn parse_headers(src: &mut BytesMut) -> usize {
+        #![allow(clippy::uninit_assumed_init)]
+
         let mut headers: [HeaderIndex; MAX_HEADERS] =
             unsafe { MaybeUninit::uninit().assume_init() };
 

actix-http/benches/write-camel-case.rs

@@ -18,7 +18,8 @@ fn bench_write_camel_case(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("New", i), bts, |b, bts| {
             b.iter(|| {
                 let mut buf = black_box([0; 24]);
-                _new::write_camel_case(black_box(bts), &mut buf)
+                let len = black_box(bts.len());
+                _new::write_camel_case(black_box(bts), buf.as_mut_ptr(), len)
             });
         });
     }
@@ -30,9 +31,12 @@ criterion_group!(benches, bench_write_camel_case);
 criterion_main!(benches);
 
 mod _new {
-    pub fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
+    pub fn write_camel_case(value: &[u8], buf: *mut u8, len: usize) {
         // first copy entire (potentially wrong) slice to output
-        buffer[..value.len()].copy_from_slice(value);
+        let buffer = unsafe {
+            std::ptr::copy_nonoverlapping(value.as_ptr(), buf, len);
+            std::slice::from_raw_parts_mut(buf, len)
+        };
 
         let mut iter = value.iter();
 

actix-http/examples/actix-web.rs

@@ -0,0 +1,26 @@
+use actix_http::HttpService;
+use actix_server::Server;
+use actix_service::map_config;
+use actix_web::{dev::AppConfig, get, App};
+
+#[get("/")]
+async fn index() -> &'static str {
+    "Hello, world. From Actix Web!"
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> std::io::Result<()> {
+    Server::build()
+        .bind("hello-world", "127.0.0.1:8080", || {
+            // construct actix-web app
+            let app = App::new().service(index);
+
+            HttpService::build()
+                // pass the app to service builder
+                // map_config is used to map App's configuration to ServiceBuilder
+                .finish(map_config(app, |_| AppConfig::default()))
+                .tcp()
+        })?
+        .run()
+        .await
+}

actix-http/examples/echo.rs

@@ -1,6 +1,6 @@
 use std::io;
 
-use actix_http::{http::StatusCode, Error, HttpService, Request, Response};
+use actix_http::{Error, HttpService, Request, Response, StatusCode};
 use actix_server::Server;
 use bytes::BytesMut;
 use futures_util::StreamExt as _;
@@ -25,10 +25,7 @@ async fn main() -> io::Result<()> {
 
                     Ok::<_, Error>(
                         Response::build(StatusCode::OK)
-                            .insert_header((
-                                "x-head",
-                                HeaderValue::from_static("dummy value!"),
-                            ))
+                            .insert_header(("x-head", HeaderValue::from_static("dummy value!")))
                             .body(body),
                     )
                 })

actix-http/examples/echo2.rs

@@ -1,12 +1,13 @@
 use std::io;
 
-use actix_http::{body::Body, http::HeaderValue, http::StatusCode};
-use actix_http::{Error, HttpService, Request, Response};
+use actix_http::{
+    body::MessageBody, header::HeaderValue, Error, HttpService, Request, Response, StatusCode,
+};
 use actix_server::Server;
 use bytes::BytesMut;
 use futures_util::StreamExt as _;
 
-async fn handle_request(mut req: Request) -> Result<Response<Body>, Error> {
+async fn handle_request(mut req: Request) -> Result<Response<impl MessageBody>, Error> {
     let mut body = BytesMut::new();
     while let Some(item) = req.payload().next().await {
         body.extend_from_slice(&item?)

actix-http/examples/hello-world.rs

@@ -1,8 +1,9 @@
 use std::{convert::Infallible, io};
 
-use actix_http::{http::StatusCode, HttpService, Response};
+use actix_http::{
+    header::HeaderValue, HttpMessage, HttpService, Request, Response, StatusCode,
+};
 use actix_server::Server;
-use http::header::HeaderValue;
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
@@ -13,13 +14,19 @@ async fn main() -> io::Result<()> {
             HttpService::build()
                 .client_timeout(1000)
                 .client_disconnect(1000)
-                .finish(|req| async move {
+                .on_connect_ext(|_, ext| {
+                    ext.insert(42u32);
+                })
+                .finish(|req: Request| async move {
                     log::info!("{:?}", req);
 
                     let mut res = Response::build(StatusCode::OK);
+                    res.insert_header(("x-head", HeaderValue::from_static("dummy value!")));
+
+                    let forty_two = req.extensions().get::<u32>().unwrap().to_string();
                     res.insert_header((
-                        "x-head",
-                        HeaderValue::from_static("dummy value!"),
+                        "x-forty-two",
+                        HeaderValue::from_str(&forty_two).unwrap(),
                     ));
 
                     Ok::<_, Infallible>(res.body("Hello world!"))

actix-http/examples/ws.rs

@@ -60,10 +60,7 @@ impl Heartbeat {
 impl Stream for Heartbeat {
     type Item = Result<Bytes, Error>;
 
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         log::trace!("poll");
 
         ready!(self.as_mut().interval.poll_tick(cx));
@@ -85,22 +82,31 @@ impl Stream for Heartbeat {
 fn tls_config() -> rustls::ServerConfig {
     use std::io::BufReader;
 
-    use rustls::{
-        internal::pemfile::{certs, pkcs8_private_keys},
-        NoClientAuth, ServerConfig,
-    };
+    use rustls::{Certificate, PrivateKey};
+    use rustls_pemfile::{certs, pkcs8_private_keys};
 
     let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
     let cert_file = cert.serialize_pem().unwrap();
     let key_file = cert.serialize_private_key_pem();
 
-    let mut config = ServerConfig::new(NoClientAuth::new());
     let cert_file = &mut BufReader::new(cert_file.as_bytes());
     let key_file = &mut BufReader::new(key_file.as_bytes());
 
-    let cert_chain = certs(cert_file).unwrap();
+    let cert_chain = certs(cert_file)
+        .unwrap()
+        .into_iter()
+        .map(Certificate)
+        .collect();
     let mut keys = pkcs8_private_keys(key_file).unwrap();
-    config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
+
+    let mut config = rustls::ServerConfig::builder()
+        .with_safe_defaults()
+        .with_no_client_auth()
+        .with_single_cert(cert_chain, PrivateKey(keys.remove(0)))
+        .unwrap();
+
+    config.alpn_protocols.push(b"http/1.1".to_vec());
+    config.alpn_protocols.push(b"h2".to_vec());
 
     config
 }

actix-http/rustfmt.toml

@@ -1,5 +0,0 @@
-max_width = 89
-reorder_imports = true
-#wrap_comments = true
-#fn_args_density = "Compressed"
-#use_small_heuristics = false

actix-http/src/body/body.rs

@@ -1,233 +0,0 @@
-use std::{
-    borrow::Cow,
-    error::Error as StdError,
-    fmt, mem,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::{Bytes, BytesMut};
-use futures_core::{ready, Stream};
-
-use crate::error::Error;
-
-use super::{BodySize, BodyStream, MessageBody, MessageBodyMapErr, SizedStream};
-
-pub type Body = AnyBody;
-
-/// Represents various types of HTTP message body.
-pub enum AnyBody {
-    /// Empty response. `Content-Length` header is not set.
-    None,
-
-    /// Zero sized response body. `Content-Length` header is set to `0`.
-    Empty,
-
-    /// Specific response body.
-    Bytes(Bytes),
-
-    /// Generic message body.
-    Message(BoxAnyBody),
-}
-
-impl AnyBody {
-    /// Create body from slice (copy)
-    pub fn from_slice(s: &[u8]) -> Self {
-        Self::Bytes(Bytes::copy_from_slice(s))
-    }
-
-    /// Create body from generic message body.
-    pub fn from_message<B>(body: B) -> Self
-    where
-        B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError + 'static>>,
-    {
-        Self::Message(BoxAnyBody::from_body(body))
-    }
-}
-
-impl MessageBody for AnyBody {
-    type Error = Error;
-
-    fn size(&self) -> BodySize {
-        match self {
-            AnyBody::None => BodySize::None,
-            AnyBody::Empty => BodySize::Empty,
-            AnyBody::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
-            AnyBody::Message(ref body) => body.size(),
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        match self.get_mut() {
-            AnyBody::None => Poll::Ready(None),
-            AnyBody::Empty => Poll::Ready(None),
-            AnyBody::Bytes(ref mut bin) => {
-                let len = bin.len();
-                if len == 0 {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(mem::take(bin))))
-                }
-            }
-
-            // TODO: MSRV 1.51: poll_map_err
-            AnyBody::Message(body) => match ready!(body.as_pin_mut().poll_next(cx)) {
-                Some(Err(err)) => {
-                    Poll::Ready(Some(Err(Error::new_body().with_cause(err))))
-                }
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
-        }
-    }
-}
-
-impl PartialEq for AnyBody {
-    fn eq(&self, other: &Body) -> bool {
-        match *self {
-            AnyBody::None => matches!(*other, AnyBody::None),
-            AnyBody::Empty => matches!(*other, AnyBody::Empty),
-            AnyBody::Bytes(ref b) => match *other {
-                AnyBody::Bytes(ref b2) => b == b2,
-                _ => false,
-            },
-            AnyBody::Message(_) => false,
-        }
-    }
-}
-
-impl fmt::Debug for AnyBody {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            AnyBody::None => write!(f, "AnyBody::None"),
-            AnyBody::Empty => write!(f, "AnyBody::Empty"),
-            AnyBody::Bytes(ref b) => write!(f, "AnyBody::Bytes({:?})", b),
-            AnyBody::Message(_) => write!(f, "AnyBody::Message(_)"),
-        }
-    }
-}
-
-impl From<&'static str> for AnyBody {
-    fn from(s: &'static str) -> Body {
-        AnyBody::Bytes(Bytes::from_static(s.as_ref()))
-    }
-}
-
-impl From<&'static [u8]> for AnyBody {
-    fn from(s: &'static [u8]) -> Body {
-        AnyBody::Bytes(Bytes::from_static(s))
-    }
-}
-
-impl From<Vec<u8>> for AnyBody {
-    fn from(vec: Vec<u8>) -> Body {
-        AnyBody::Bytes(Bytes::from(vec))
-    }
-}
-
-impl From<String> for AnyBody {
-    fn from(s: String) -> Body {
-        s.into_bytes().into()
-    }
-}
-
-impl From<&'_ String> for AnyBody {
-    fn from(s: &String) -> Body {
-        AnyBody::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
-    }
-}
-
-impl From<Cow<'_, str>> for AnyBody {
-    fn from(s: Cow<'_, str>) -> Body {
-        match s {
-            Cow::Owned(s) => AnyBody::from(s),
-            Cow::Borrowed(s) => {
-                AnyBody::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(s)))
-            }
-        }
-    }
-}
-
-impl From<Bytes> for AnyBody {
-    fn from(s: Bytes) -> Body {
-        AnyBody::Bytes(s)
-    }
-}
-
-impl From<BytesMut> for AnyBody {
-    fn from(s: BytesMut) -> Body {
-        AnyBody::Bytes(s.freeze())
-    }
-}
-
-impl<S, E> From<SizedStream<S>> for AnyBody
-where
-    S: Stream<Item = Result<Bytes, E>> + 'static,
-    E: Into<Box<dyn StdError>> + 'static,
-{
-    fn from(s: SizedStream<S>) -> Body {
-        AnyBody::from_message(s)
-    }
-}
-
-impl<S, E> From<BodyStream<S>> for AnyBody
-where
-    S: Stream<Item = Result<Bytes, E>> + 'static,
-    E: Into<Box<dyn StdError>> + 'static,
-{
-    fn from(s: BodyStream<S>) -> Body {
-        AnyBody::from_message(s)
-    }
-}
-
-/// A boxed message body with boxed errors.
-pub struct BoxAnyBody(Pin<Box<dyn MessageBody<Error = Box<dyn StdError + 'static>>>>);
-
-impl BoxAnyBody {
-    /// Boxes a `MessageBody` and any errors it generates.
-    pub fn from_body<B>(body: B) -> Self
-    where
-        B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError + 'static>>,
-    {
-        let body = MessageBodyMapErr::new(body, Into::into);
-        Self(Box::pin(body))
-    }
-
-    /// Returns a mutable pinned reference to the inner message body type.
-    pub fn as_pin_mut(
-        &mut self,
-    ) -> Pin<&mut (dyn MessageBody<Error = Box<dyn StdError + 'static>>)> {
-        self.0.as_mut()
-    }
-}
-
-impl fmt::Debug for BoxAnyBody {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("BoxAnyBody(dyn MessageBody)")
-    }
-}
-
-impl MessageBody for BoxAnyBody {
-    type Error = Error;
-
-    fn size(&self) -> BodySize {
-        self.0.size()
-    }
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        // TODO: MSRV 1.51: poll_map_err
-        match ready!(self.0.as_mut().poll_next(cx)) {
-            Some(Err(err)) => Poll::Ready(Some(Err(Error::new_body().with_cause(err)))),
-            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-            None => Poll::Ready(None),
-        }
-    }
-}

actix-http/src/body/body_stream.rs

@@ -20,11 +20,14 @@ pin_project! {
     }
 }
 
+// TODO: from_infallible method
+
 impl<S, E> BodyStream<S>
 where
     S: Stream<Item = Result<Bytes, E>>,
     E: Into<Box<dyn StdError>> + 'static,
 {
+    #[inline]
     pub fn new(stream: S) -> Self {
         BodyStream { stream }
     }
@@ -37,6 +40,7 @@ where
 {
     type Error = E;
 
+    #[inline]
     fn size(&self) -> BodySize {
         BodySize::Stream
     }
@@ -75,10 +79,23 @@ mod tests {
     use derive_more::{Display, Error};
     use futures_core::ready;
     use futures_util::{stream, FutureExt as _};
+    use pin_project_lite::pin_project;
+    use static_assertions::{assert_impl_all, assert_not_impl_all};
 
     use super::*;
     use crate::body::to_bytes;
 
+    assert_impl_all!(BodyStream<stream::Empty<Result<Bytes, crate::Error>>>: MessageBody);
+    assert_impl_all!(BodyStream<stream::Empty<Result<Bytes, &'static str>>>: MessageBody);
+    assert_impl_all!(BodyStream<stream::Repeat<Result<Bytes, &'static str>>>: MessageBody);
+    assert_impl_all!(BodyStream<stream::Empty<Result<Bytes, Infallible>>>: MessageBody);
+    assert_impl_all!(BodyStream<stream::Repeat<Result<Bytes, Infallible>>>: MessageBody);
+
+    assert_not_impl_all!(BodyStream<stream::Empty<Bytes>>: MessageBody);
+    assert_not_impl_all!(BodyStream<stream::Repeat<Bytes>>: MessageBody);
+    // crate::Error is not Clone
+    assert_not_impl_all!(BodyStream<stream::Repeat<Result<Bytes, crate::Error>>>: MessageBody);
+
     #[actix_rt::test]
     async fn skips_empty_chunks() {
         let body = BodyStream::new(stream::iter(
@@ -124,18 +141,43 @@ mod tests {
         assert!(matches!(to_bytes(body).await, Err(StreamErr)));
     }
 
+    #[actix_rt::test]
+    async fn stream_string_error() {
+        // `&'static str` does not impl `Error`
+        // but it does impl `Into<Box<dyn Error>>`
+
+        let body = BodyStream::new(stream::once(async { Err("stringy error") }));
+        assert!(matches!(to_bytes(body).await, Err("stringy error")));
+    }
+
+    #[actix_rt::test]
+    async fn stream_boxed_error() {
+        // `Box<dyn Error>` does not impl `Error`
+        // but it does impl `Into<Box<dyn Error>>`
+
+        let body = BodyStream::new(stream::once(async {
+            Err(Box::<dyn StdError>::from("stringy error"))
+        }));
+
+        assert_eq!(
+            to_bytes(body).await.unwrap_err().to_string(),
+            "stringy error"
+        );
+    }
+
     #[actix_rt::test]
     async fn stream_delayed_error() {
-        let body =
-            BodyStream::new(stream::iter(vec![Ok(Bytes::from("1")), Err(StreamErr)]));
+        let body = BodyStream::new(stream::iter(vec![Ok(Bytes::from("1")), Err(StreamErr)]));
         assert!(matches!(to_bytes(body).await, Err(StreamErr)));
 
-        #[pin_project::pin_project(project = TimeDelayStreamProj)]
-        #[derive(Debug)]
-        enum TimeDelayStream {
-            Start,
-            Sleep(Pin<Box<Sleep>>),
-            Done,
+        pin_project! {
+            #[derive(Debug)]
+            #[project = TimeDelayStreamProj]
+            enum TimeDelayStream {
+                Start,
+                Sleep { delay: Pin<Box<Sleep>> },
+                Done,
+            }
         }
 
         impl Stream for TimeDelayStream {
@@ -148,12 +190,14 @@ mod tests {
                 match self.as_mut().get_mut() {
                     TimeDelayStream::Start => {
                         let sleep = sleep(Duration::from_millis(1));
-                        self.as_mut().set(TimeDelayStream::Sleep(Box::pin(sleep)));
+                        self.as_mut().set(TimeDelayStream::Sleep {
+                            delay: Box::pin(sleep),
+                        });
                         cx.waker().wake_by_ref();
                         Poll::Pending
                     }
 
-                    TimeDelayStream::Sleep(ref mut delay) => {
+                    TimeDelayStream::Sleep { ref mut delay } => {
                         ready!(delay.poll_unpin(cx));
                         self.set(TimeDelayStream::Done);
                         cx.waker().wake_by_ref();

actix-http/src/body/boxed.rs

@@ -0,0 +1,127 @@
+use std::{
+    error::Error as StdError,
+    fmt,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+
+use super::{BodySize, MessageBody, MessageBodyMapErr};
+use crate::body;
+
+/// A boxed message body with boxed errors.
+#[derive(Debug)]
+pub struct BoxBody(BoxBodyInner);
+
+enum BoxBodyInner {
+    None(body::None),
+    Bytes(Bytes),
+    Stream(Pin<Box<dyn MessageBody<Error = Box<dyn StdError>>>>),
+}
+
+impl fmt::Debug for BoxBodyInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::None(arg0) => f.debug_tuple("None").field(arg0).finish(),
+            Self::Bytes(arg0) => f.debug_tuple("Bytes").field(arg0).finish(),
+            Self::Stream(_) => f.debug_tuple("Stream").field(&"dyn MessageBody").finish(),
+        }
+    }
+}
+
+impl BoxBody {
+    /// Same as `MessageBody::boxed`.
+    ///
+    /// If the body type to wrap is unknown or generic it is better to use [`MessageBody::boxed`] to
+    /// avoid double boxing.
+    #[inline]
+    pub fn new<B>(body: B) -> Self
+    where
+        B: MessageBody + 'static,
+    {
+        match body.size() {
+            BodySize::None => Self(BoxBodyInner::None(body::None)),
+            _ => match body.try_into_bytes() {
+                Ok(bytes) => Self(BoxBodyInner::Bytes(bytes)),
+                Err(body) => {
+                    let body = MessageBodyMapErr::new(body, Into::into);
+                    Self(BoxBodyInner::Stream(Box::pin(body)))
+                }
+            },
+        }
+    }
+
+    /// Returns a mutable pinned reference to the inner message body type.
+    #[inline]
+    pub fn as_pin_mut(&mut self) -> Pin<&mut Self> {
+        Pin::new(self)
+    }
+}
+
+impl MessageBody for BoxBody {
+    type Error = Box<dyn StdError>;
+
+    #[inline]
+    fn size(&self) -> BodySize {
+        match &self.0 {
+            BoxBodyInner::None(none) => none.size(),
+            BoxBodyInner::Bytes(bytes) => bytes.size(),
+            BoxBodyInner::Stream(stream) => stream.size(),
+        }
+    }
+
+    #[inline]
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        match &mut self.0 {
+            BoxBodyInner::None(body) => {
+                Pin::new(body).poll_next(cx).map_err(|err| match err {})
+            }
+            BoxBodyInner::Bytes(body) => {
+                Pin::new(body).poll_next(cx).map_err(|err| match err {})
+            }
+            BoxBodyInner::Stream(body) => Pin::new(body).poll_next(cx),
+        }
+    }
+
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self> {
+        match self.0 {
+            BoxBodyInner::None(body) => Ok(body.try_into_bytes().unwrap()),
+            BoxBodyInner::Bytes(body) => Ok(body.try_into_bytes().unwrap()),
+            _ => Err(self),
+        }
+    }
+
+    #[inline]
+    fn boxed(self) -> BoxBody {
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use static_assertions::{assert_impl_all, assert_not_impl_all};
+
+    use super::*;
+    use crate::body::to_bytes;
+
+    assert_impl_all!(BoxBody: MessageBody, fmt::Debug, Unpin);
+
+    assert_not_impl_all!(BoxBody: Send, Sync, Unpin);
+
+    #[actix_rt::test]
+    async fn nested_boxed_body() {
+        let body = Bytes::from_static(&[1, 2, 3]);
+        let boxed_body = BoxBody::new(BoxBody::new(body));
+
+        assert_eq!(
+            to_bytes(boxed_body).await.unwrap(),
+            Bytes::from(vec![1, 2, 3]),
+        );
+    }
+}

actix-http/src/body/either.rs

@@ -0,0 +1,108 @@
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use pin_project_lite::pin_project;
+
+use super::{BodySize, BoxBody, MessageBody};
+use crate::Error;
+
+pin_project! {
+    #[project = EitherBodyProj]
+    #[derive(Debug, Clone)]
+    pub enum EitherBody<L, R = BoxBody> {
+        /// A body of type `L`.
+        Left { #[pin] body: L },
+
+        /// A body of type `R`.
+        Right { #[pin] body: R },
+    }
+}
+
+impl<L> EitherBody<L, BoxBody> {
+    /// Creates new `EitherBody` using left variant and boxed right variant.
+    #[inline]
+    pub fn new(body: L) -> Self {
+        Self::Left { body }
+    }
+}
+
+impl<L, R> EitherBody<L, R> {
+    /// Creates new `EitherBody` using left variant.
+    #[inline]
+    pub fn left(body: L) -> Self {
+        Self::Left { body }
+    }
+
+    /// Creates new `EitherBody` using right variant.
+    #[inline]
+    pub fn right(body: R) -> Self {
+        Self::Right { body }
+    }
+}
+
+impl<L, R> MessageBody for EitherBody<L, R>
+where
+    L: MessageBody + 'static,
+    R: MessageBody + 'static,
+{
+    type Error = Error;
+
+    #[inline]
+    fn size(&self) -> BodySize {
+        match self {
+            EitherBody::Left { body } => body.size(),
+            EitherBody::Right { body } => body.size(),
+        }
+    }
+
+    #[inline]
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        match self.project() {
+            EitherBodyProj::Left { body } => body
+                .poll_next(cx)
+                .map_err(|err| Error::new_body().with_cause(err)),
+            EitherBodyProj::Right { body } => body
+                .poll_next(cx)
+                .map_err(|err| Error::new_body().with_cause(err)),
+        }
+    }
+
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self> {
+        match self {
+            EitherBody::Left { body } => body
+                .try_into_bytes()
+                .map_err(|body| EitherBody::Left { body }),
+            EitherBody::Right { body } => body
+                .try_into_bytes()
+                .map_err(|body| EitherBody::Right { body }),
+        }
+    }
+
+    #[inline]
+    fn boxed(self) -> BoxBody {
+        match self {
+            EitherBody::Left { body } => body.boxed(),
+            EitherBody::Right { body } => body.boxed(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn type_parameter_inference() {
+        let _body: EitherBody<(), _> = EitherBody::new(());
+
+        let _body: EitherBody<_, ()> = EitherBody::left(());
+        let _body: EitherBody<(), _> = EitherBody::right(());
+    }
+}

actix-http/src/body/message_body.rs

@@ -2,6 +2,7 @@
 
 use std::{
     convert::Infallible,
+    error::Error as StdError,
     mem,
     pin::Pin,
     task::{Context, Poll},
@@ -11,172 +12,317 @@ use bytes::{Bytes, BytesMut};
 use futures_core::ready;
 use pin_project_lite::pin_project;
 
-use crate::error::Error;
+use super::{BodySize, BoxBody};
 
-use super::BodySize;
-
-/// An interface for response bodies.
+/// An interface types that can converted to bytes and used as response bodies.
+// TODO: examples
 pub trait MessageBody {
-    type Error;
+    /// The type of error that will be returned if streaming body fails.
+    ///
+    /// Since it is not appropriate to generate a response mid-stream, it only requires `Error` for
+    /// internal use and logging.
+    type Error: Into<Box<dyn StdError>>;
 
     /// Body size hint.
+    ///
+    /// If [`BodySize::None`] is returned, optimizations that skip reading the body are allowed.
     fn size(&self) -> BodySize;
 
     /// Attempt to pull out the next chunk of body bytes.
+    // TODO: expand documentation
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, Self::Error>>>;
-}
 
-impl MessageBody for () {
-    type Error = Infallible;
-
-    fn size(&self) -> BodySize {
-        BodySize::Empty
+    /// Try to convert into the complete chunk of body bytes.
+    ///
+    /// Implement this method if the entire body can be trivially extracted. This is useful for
+    /// optimizations where `poll_next` calls can be avoided.
+    ///
+    /// Body types with [`BodySize::None`] are allowed to return empty `Bytes`. Although, if calling
+    /// this method, it is recommended to check `size` first and return early.
+    ///
+    /// # Errors
+    /// The default implementation will error and return the original type back to the caller for
+    /// further use.
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self>
+    where
+        Self: Sized,
+    {
+        Err(self)
     }
 
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        Poll::Ready(None)
+    /// Converts this body into `BoxBody`.
+    #[inline]
+    fn boxed(self) -> BoxBody
+    where
+        Self: Sized + 'static,
+    {
+        BoxBody::new(self)
     }
 }
 
-impl<B> MessageBody for Box<B>
-where
-    B: MessageBody + Unpin,
-    B::Error: Into<Error>,
-{
-    type Error = B::Error;
+mod foreign_impls {
+    use super::*;
 
-    fn size(&self) -> BodySize {
-        self.as_ref().size()
-    }
+    impl MessageBody for Infallible {
+        type Error = Infallible;
 
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        Pin::new(self.get_mut().as_mut()).poll_next(cx)
-    }
-}
+        fn size(&self) -> BodySize {
+            match *self {}
+        }
 
-impl<B> MessageBody for Pin<Box<B>>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    type Error = B::Error;
-
-    fn size(&self) -> BodySize {
-        self.as_ref().size()
-    }
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        self.as_mut().poll_next(cx)
-    }
-}
-
-impl MessageBody for Bytes {
-    type Error = Infallible;
-
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            match *self {}
         }
     }
-}
 
-impl MessageBody for BytesMut {
-    type Error = Infallible;
+    impl MessageBody for () {
+        type Error = Infallible;
 
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(0)
+        }
 
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
             Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            Ok(Bytes::new())
         }
     }
-}
 
-impl MessageBody for &'static str {
-    type Error = Infallible;
+    impl<B> MessageBody for Box<B>
+    where
+        B: MessageBody + Unpin + ?Sized,
+    {
+        type Error = B::Error;
 
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
+        #[inline]
+        fn size(&self) -> BodySize {
+            self.as_ref().size()
+        }
 
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from_static(
-                mem::take(self.get_mut()).as_ref(),
-            ))))
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            Pin::new(self.get_mut().as_mut()).poll_next(cx)
         }
     }
-}
 
-impl MessageBody for Vec<u8> {
-    type Error = Infallible;
+    impl<B> MessageBody for Pin<Box<B>>
+    where
+        B: MessageBody + ?Sized,
+    {
+        type Error = B::Error;
 
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
+        #[inline]
+        fn size(&self) -> BodySize {
+            self.as_ref().size()
+        }
 
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            self.get_mut().as_mut().poll_next(cx)
         }
     }
-}
 
-impl MessageBody for String {
-    type Error = Infallible;
+    impl MessageBody for &'static [u8] {
+        type Error = Infallible;
 
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            if self.is_empty() {
+                Poll::Ready(None)
+            } else {
+                Poll::Ready(Some(Ok(Bytes::from_static(mem::take(self.get_mut())))))
+            }
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            Ok(Bytes::from_static(self))
+        }
     }
 
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from(
-                mem::take(self.get_mut()).into_bytes(),
-            ))))
+    impl MessageBody for Bytes {
+        type Error = Infallible;
+
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            if self.is_empty() {
+                Poll::Ready(None)
+            } else {
+                Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
+            }
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            Ok(self)
+        }
+    }
+
+    impl MessageBody for BytesMut {
+        type Error = Infallible;
+
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            if self.is_empty() {
+                Poll::Ready(None)
+            } else {
+                Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
+            }
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            Ok(self.freeze())
+        }
+    }
+
+    impl MessageBody for Vec<u8> {
+        type Error = Infallible;
+
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            if self.is_empty() {
+                Poll::Ready(None)
+            } else {
+                Poll::Ready(Some(Ok(mem::take(self.get_mut()).into())))
+            }
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            Ok(Bytes::from(self))
+        }
+    }
+
+    impl MessageBody for &'static str {
+        type Error = Infallible;
+
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            if self.is_empty() {
+                Poll::Ready(None)
+            } else {
+                let string = mem::take(self.get_mut());
+                let bytes = Bytes::from_static(string.as_bytes());
+                Poll::Ready(Some(Ok(bytes)))
+            }
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            Ok(Bytes::from_static(self.as_bytes()))
+        }
+    }
+
+    impl MessageBody for String {
+        type Error = Infallible;
+
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            if self.is_empty() {
+                Poll::Ready(None)
+            } else {
+                let string = mem::take(self.get_mut());
+                Poll::Ready(Some(Ok(Bytes::from(string))))
+            }
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            Ok(Bytes::from(self))
+        }
+    }
+
+    impl MessageBody for bytestring::ByteString {
+        type Error = Infallible;
+
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            let string = mem::take(self.get_mut());
+            Poll::Ready(Some(Ok(string.into_bytes())))
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            Ok(self.into_bytes())
         }
     }
 }
@@ -206,9 +352,11 @@ impl<B, F, E> MessageBody for MessageBodyMapErr<B, F>
 where
     B: MessageBody,
     F: FnOnce(B::Error) -> E,
+    E: Into<Box<dyn StdError>>,
 {
     type Error = E;
 
+    #[inline]
     fn size(&self) -> BodySize {
         self.body.size()
     }
@@ -229,4 +377,178 @@ where
             None => Poll::Ready(None),
         }
     }
+
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self> {
+        let Self { body, mapper } = self;
+        body.try_into_bytes().map_err(|body| Self { body, mapper })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use actix_rt::pin;
+    use actix_utils::future::poll_fn;
+    use bytes::{Bytes, BytesMut};
+
+    use super::*;
+    use crate::body::{self, EitherBody};
+
+    macro_rules! assert_poll_next {
+        ($pin:expr, $exp:expr) => {
+            assert_eq!(
+                poll_fn(|cx| $pin.as_mut().poll_next(cx))
+                    .await
+                    .unwrap() // unwrap option
+                    .unwrap(), // unwrap result
+                $exp
+            );
+        };
+    }
+
+    macro_rules! assert_poll_next_none {
+        ($pin:expr) => {
+            assert!(poll_fn(|cx| $pin.as_mut().poll_next(cx)).await.is_none());
+        };
+    }
+
+    #[actix_rt::test]
+    async fn boxing_equivalence() {
+        assert_eq!(().size(), BodySize::Sized(0));
+        assert_eq!(().size(), Box::new(()).size());
+        assert_eq!(().size(), Box::pin(()).size());
+
+        let pl = Box::new(());
+        pin!(pl);
+        assert_poll_next_none!(pl);
+
+        let mut pl = Box::pin(());
+        assert_poll_next_none!(pl);
+    }
+
+    #[actix_rt::test]
+    async fn test_unit() {
+        let pl = ();
+        assert_eq!(pl.size(), BodySize::Sized(0));
+        pin!(pl);
+        assert_poll_next_none!(pl);
+    }
+
+    #[actix_rt::test]
+    async fn test_static_str() {
+        assert_eq!("".size(), BodySize::Sized(0));
+        assert_eq!("test".size(), BodySize::Sized(4));
+
+        let pl = "test";
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_static_bytes() {
+        assert_eq!(b"".as_ref().size(), BodySize::Sized(0));
+        assert_eq!(b"test".as_ref().size(), BodySize::Sized(4));
+
+        let pl = b"test".as_ref();
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_vec() {
+        assert_eq!(vec![0; 0].size(), BodySize::Sized(0));
+        assert_eq!(Vec::from("test").size(), BodySize::Sized(4));
+
+        let pl = Vec::from("test");
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_bytes() {
+        assert_eq!(Bytes::new().size(), BodySize::Sized(0));
+        assert_eq!(Bytes::from_static(b"test").size(), BodySize::Sized(4));
+
+        let pl = Bytes::from_static(b"test");
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_bytes_mut() {
+        assert_eq!(BytesMut::new().size(), BodySize::Sized(0));
+        assert_eq!(BytesMut::from(b"test".as_ref()).size(), BodySize::Sized(4));
+
+        let pl = BytesMut::from("test");
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_string() {
+        assert_eq!(String::new().size(), BodySize::Sized(0));
+        assert_eq!("test".to_owned().size(), BodySize::Sized(4));
+
+        let pl = "test".to_owned();
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn complete_body_combinators() {
+        let body = Bytes::from_static(b"test");
+        let body = BoxBody::new(body);
+        let body = EitherBody::<_, ()>::left(body);
+        let body = EitherBody::<(), _>::right(body);
+        // Do not support try_into_bytes:
+        // let body = Box::new(body);
+        // let body = Box::pin(body);
+
+        assert_eq!(body.try_into_bytes().unwrap(), Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn complete_body_combinators_poll() {
+        let body = Bytes::from_static(b"test");
+        let body = BoxBody::new(body);
+        let body = EitherBody::<_, ()>::left(body);
+        let body = EitherBody::<(), _>::right(body);
+        let mut body = body;
+
+        assert_eq!(body.size(), BodySize::Sized(4));
+        assert_poll_next!(Pin::new(&mut body), Bytes::from("test"));
+        assert_poll_next_none!(Pin::new(&mut body));
+    }
+
+    #[actix_rt::test]
+    async fn none_body_combinators() {
+        fn none_body() -> BoxBody {
+            let body = body::None;
+            let body = BoxBody::new(body);
+            let body = EitherBody::<_, ()>::left(body);
+            let body = EitherBody::<(), _>::right(body);
+            body.boxed()
+        }
+
+        assert_eq!(none_body().size(), BodySize::None);
+        assert_eq!(none_body().try_into_bytes().unwrap(), Bytes::new());
+        assert_poll_next_none!(Pin::new(&mut none_body()));
+    }
+
+    // down-casting used to be done with a method on MessageBody trait
+    // test is kept to demonstrate equivalence of Any trait
+    #[actix_rt::test]
+    async fn test_body_casting() {
+        let mut body = String::from("hello cast");
+        // let mut resp_body: &mut dyn MessageBody<Error = Error> = &mut body;
+        let resp_body: &mut dyn std::any::Any = &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/body/mod.rs

@@ -1,263 +1,20 @@
 //! Traits and structures to aid consuming and writing HTTP payloads.
 
-use std::task::Poll;
-
-use actix_rt::pin;
-use actix_utils::future::poll_fn;
-use bytes::{Bytes, BytesMut};
-use futures_core::ready;
-
-#[allow(clippy::module_inception)]
-mod body;
 mod body_stream;
+mod boxed;
+mod either;
 mod message_body;
-mod response_body;
+mod none;
 mod size;
 mod sized_stream;
+mod utils;
 
-pub use self::body::{AnyBody, Body, BoxAnyBody};
 pub use self::body_stream::BodyStream;
+pub use self::boxed::BoxBody;
+pub use self::either::EitherBody;
 pub use self::message_body::MessageBody;
 pub(crate) use self::message_body::MessageBodyMapErr;
-pub use self::response_body::ResponseBody;
+pub use self::none::None;
 pub use self::size::BodySize;
 pub use self::sized_stream::SizedStream;
-
-/// Collects the body produced by a `MessageBody` implementation into `Bytes`.
-///
-/// Any errors produced by the body stream are returned immediately.
-///
-/// # Examples
-/// ```
-/// use actix_http::body::{Body, to_bytes};
-/// use bytes::Bytes;
-///
-/// # async fn test_to_bytes() {
-/// let body = Body::Empty;
-/// let bytes = to_bytes(body).await.unwrap();
-/// assert!(bytes.is_empty());
-///
-/// let body = Body::Bytes(Bytes::from_static(b"123"));
-/// let bytes = to_bytes(body).await.unwrap();
-/// assert_eq!(bytes, b"123"[..]);
-/// # }
-/// ```
-pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
-    let cap = match body.size() {
-        BodySize::None | BodySize::Empty | BodySize::Sized(0) => return Ok(Bytes::new()),
-        BodySize::Sized(size) => size as usize,
-        BodySize::Stream => 32_768,
-    };
-
-    let mut buf = BytesMut::with_capacity(cap);
-
-    pin!(body);
-
-    poll_fn(|cx| loop {
-        let body = body.as_mut();
-
-        match ready!(body.poll_next(cx)) {
-            Some(Ok(bytes)) => buf.extend_from_slice(&*bytes),
-            None => return Poll::Ready(Ok(())),
-            Some(Err(err)) => return Poll::Ready(Err(err)),
-        }
-    })
-    .await?;
-
-    Ok(buf.freeze())
-}
-
-#[cfg(test)]
-mod tests {
-    use std::pin::Pin;
-
-    use actix_rt::pin;
-    use actix_utils::future::poll_fn;
-    use bytes::{Bytes, BytesMut};
-
-    use super::*;
-
-    impl Body {
-        pub(crate) fn get_ref(&self) -> &[u8] {
-            match *self {
-                Body::Bytes(ref bin) => &bin,
-                _ => panic!(),
-            }
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_static_str() {
-        assert_eq!(Body::from("").size(), BodySize::Sized(0));
-        assert_eq!(Body::from("test").size(), BodySize::Sized(4));
-        assert_eq!(Body::from("test").get_ref(), b"test");
-
-        assert_eq!("test".size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_static_bytes() {
-        assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
-        assert_eq!(
-            Body::from_slice(b"test".as_ref()).size(),
-            BodySize::Sized(4)
-        );
-        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
-        let sb = Bytes::from(&b"test"[..]);
-        pin!(sb);
-
-        assert_eq!(sb.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    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!(test_vec);
-
-        assert_eq!(test_vec.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| test_vec.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_bytes() {
-        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!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            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 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!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_string() {
-        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!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_unit() {
-        assert_eq!(().size(), BodySize::Empty);
-        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
-            .await
-            .is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_box_and_pin() {
-        let val = Box::new(());
-        pin!(val);
-        assert_eq!(val.size(), BodySize::Empty);
-        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
-
-        let mut val = Box::pin(());
-        assert_eq!(val.size(), BodySize::Empty);
-        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_body_eq() {
-        assert!(
-            Body::Bytes(Bytes::from_static(b"1"))
-                == Body::Bytes(Bytes::from_static(b"1"))
-        );
-        assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
-    }
-
-    #[actix_rt::test]
-    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'));
-    }
-
-    #[actix_rt::test]
-    async fn test_serde_json() {
-        use serde_json::{json, Value};
-        assert_eq!(
-            Body::from(serde_json::to_vec(&Value::String("test".to_owned())).unwrap())
-                .size(),
-            BodySize::Sized(6)
-        );
-        assert_eq!(
-            Body::from(serde_json::to_vec(&json!({"test-key":"test-value"})).unwrap())
-                .size(),
-            BodySize::Sized(25)
-        );
-    }
-
-    // down-casting used to be done with a method on MessageBody trait
-    // test is kept to demonstrate equivalence of Any trait
-    #[actix_rt::test]
-    async fn test_body_casting() {
-        let mut body = String::from("hello cast");
-        // let mut resp_body: &mut dyn MessageBody<Error = Error> = &mut body;
-        let resp_body: &mut dyn std::any::Any = &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_rt::test]
-    async fn test_to_bytes() {
-        let body = Body::Empty;
-        let bytes = to_bytes(body).await.unwrap();
-        assert!(bytes.is_empty());
-
-        let body = Body::Bytes(Bytes::from_static(b"123"));
-        let bytes = to_bytes(body).await.unwrap();
-        assert_eq!(bytes, b"123"[..]);
-    }
-}
+pub use self::utils::to_bytes;

actix-http/src/body/none.rs

@@ -0,0 +1,48 @@
+use std::{
+    convert::Infallible,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+
+use super::{BodySize, MessageBody};
+
+/// Body type for responses that forbid payloads.
+///
+/// Distinct from an empty response which would contain a Content-Length header.
+///
+/// For an "empty" body, use `()` or `Bytes::new()`.
+#[derive(Debug, Clone, Copy, Default)]
+#[non_exhaustive]
+pub struct None;
+
+impl None {
+    /// Constructs new "none" body.
+    #[inline]
+    pub fn new() -> Self {
+        None
+    }
+}
+
+impl MessageBody for None {
+    type Error = Infallible;
+
+    #[inline]
+    fn size(&self) -> BodySize {
+        BodySize::None
+    }
+
+    #[inline]
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        Poll::Ready(Option::None)
+    }
+
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self> {
+        Ok(Bytes::new())
+    }
+}

actix-http/src/body/response_body.rs

@@ -1,89 +0,0 @@
-use std::{
-    mem,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::Bytes;
-use futures_core::{ready, Stream};
-use pin_project::pin_project;
-
-use crate::error::Error;
-
-use super::{Body, BodySize, MessageBody};
-
-#[pin_project(project = ResponseBodyProj)]
-pub enum ResponseBody<B> {
-    Body(#[pin] B),
-    Other(Body),
-}
-
-impl ResponseBody<Body> {
-    pub fn into_body<B>(self) -> ResponseBody<B> {
-        match self {
-            ResponseBody::Body(b) => ResponseBody::Other(b),
-            ResponseBody::Other(b) => ResponseBody::Other(b),
-        }
-    }
-}
-
-impl<B> ResponseBody<B> {
-    pub fn take_body(&mut self) -> ResponseBody<B> {
-        mem::replace(self, ResponseBody::Other(Body::None))
-    }
-}
-
-impl<B: MessageBody> ResponseBody<B> {
-    pub fn as_ref(&self) -> Option<&B> {
-        if let ResponseBody::Body(ref b) = self {
-            Some(b)
-        } else {
-            None
-        }
-    }
-}
-
-impl<B> MessageBody for ResponseBody<B>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    type Error = Error;
-
-    fn size(&self) -> BodySize {
-        match self {
-            ResponseBody::Body(ref body) => body.size(),
-            ResponseBody::Other(ref body) => body.size(),
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        Stream::poll_next(self, cx)
-    }
-}
-
-impl<B> Stream for ResponseBody<B>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    type Item = Result<Bytes, Error>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        match self.project() {
-            // TODO: MSRV 1.51: poll_map_err
-            ResponseBodyProj::Body(body) => match ready!(body.poll_next(cx)) {
-                Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
-            ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
-        }
-    }
-}

actix-http/src/body/size.rs

@@ -1,19 +1,16 @@
 /// Body size hint.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BodySize {
-    /// Absence of body can be assumed from method or status code.
+    /// Implicitly empty body.
     ///
-    /// Will skip writing Content-Length header.
+    /// Will omit the Content-Length header. Used for responses to certain methods (e.g., `HEAD`) or
+    /// with particular status codes (e.g., 204 No Content). Consumers that read this as a body size
+    /// hint are allowed to make optimizations that skip reading or writing the payload.
     None,
 
-    /// Zero size body.
-    ///
-    /// Will write `Content-Length: 0` header.
-    Empty,
-
     /// Known size body.
     ///
-    /// Will write `Content-Length: N` header. `Sized(0)` is treated the same as `Empty`.
+    /// Will write `Content-Length: N` header.
     Sized(u64),
 
     /// Unknown size body.
@@ -23,18 +20,22 @@ pub enum BodySize {
 }
 
 impl BodySize {
-    /// Returns true if size hint indicates no or empty body.
+    /// Equivalent to `BodySize::Sized(0)`;
+    pub const ZERO: Self = Self::Sized(0);
+
+    /// Returns true if size hint indicates omitted or empty body.
+    ///
+    /// Streams will return false because it cannot be known without reading the stream.
     ///
     /// ```
     /// # use actix_http::body::BodySize;
     /// assert!(BodySize::None.is_eof());
-    /// assert!(BodySize::Empty.is_eof());
     /// assert!(BodySize::Sized(0).is_eof());
     ///
     /// assert!(!BodySize::Sized(64).is_eof());
     /// assert!(!BodySize::Stream.is_eof());
     /// ```
     pub fn is_eof(&self) -> bool {
-        matches!(self, BodySize::None | BodySize::Empty | BodySize::Sized(0))
+        matches!(self, BodySize::None | BodySize::Sized(0))
     }
 }

actix-http/src/body/sized_stream.rs

@@ -27,11 +27,14 @@ where
     S: Stream<Item = Result<Bytes, E>>,
     E: Into<Box<dyn StdError>> + 'static,
 {
+    #[inline]
     pub fn new(size: u64, stream: S) -> Self {
         SizedStream { size, stream }
     }
 }
 
+// TODO: from_infallible method
+
 impl<S, E> MessageBody for SizedStream<S>
 where
     S: Stream<Item = Result<Bytes, E>>,
@@ -39,6 +42,7 @@ where
 {
     type Error = E;
 
+    #[inline]
     fn size(&self) -> BodySize {
         BodySize::Sized(self.size as u64)
     }
@@ -72,10 +76,22 @@ mod tests {
     use actix_rt::pin;
     use actix_utils::future::poll_fn;
     use futures_util::stream;
+    use static_assertions::{assert_impl_all, assert_not_impl_all};
 
     use super::*;
     use crate::body::to_bytes;
 
+    assert_impl_all!(SizedStream<stream::Empty<Result<Bytes, crate::Error>>>: MessageBody);
+    assert_impl_all!(SizedStream<stream::Empty<Result<Bytes, &'static str>>>: MessageBody);
+    assert_impl_all!(SizedStream<stream::Repeat<Result<Bytes, &'static str>>>: MessageBody);
+    assert_impl_all!(SizedStream<stream::Empty<Result<Bytes, Infallible>>>: MessageBody);
+    assert_impl_all!(SizedStream<stream::Repeat<Result<Bytes, Infallible>>>: MessageBody);
+
+    assert_not_impl_all!(SizedStream<stream::Empty<Bytes>>: MessageBody);
+    assert_not_impl_all!(SizedStream<stream::Repeat<Bytes>>: MessageBody);
+    // crate::Error is not Clone
+    assert_not_impl_all!(SizedStream<stream::Repeat<Result<Bytes, crate::Error>>>: MessageBody);
+
     #[actix_rt::test]
     async fn skips_empty_chunks() {
         let body = SizedStream::new(
@@ -119,4 +135,37 @@ mod tests {
 
         assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
     }
+
+    #[actix_rt::test]
+    async fn stream_string_error() {
+        // `&'static str` does not impl `Error`
+        // but it does impl `Into<Box<dyn Error>>`
+
+        let body = SizedStream::new(0, stream::once(async { Err("stringy error") }));
+        assert_eq!(to_bytes(body).await, Ok(Bytes::new()));
+
+        let body = SizedStream::new(1, stream::once(async { Err("stringy error") }));
+        assert!(matches!(to_bytes(body).await, Err("stringy error")));
+    }
+
+    #[actix_rt::test]
+    async fn stream_boxed_error() {
+        // `Box<dyn Error>` does not impl `Error`
+        // but it does impl `Into<Box<dyn Error>>`
+
+        let body = SizedStream::new(
+            0,
+            stream::once(async { Err(Box::<dyn StdError>::from("stringy error")) }),
+        );
+        assert_eq!(to_bytes(body).await.unwrap(), Bytes::new());
+
+        let body = SizedStream::new(
+            1,
+            stream::once(async { Err(Box::<dyn StdError>::from("stringy error")) }),
+        );
+        assert_eq!(
+            to_bytes(body).await.unwrap_err().to_string(),
+            "stringy error"
+        );
+    }
 }

actix-http/src/body/utils.rs

@@ -0,0 +1,77 @@
+use std::task::Poll;
+
+use actix_rt::pin;
+use actix_utils::future::poll_fn;
+use bytes::{Bytes, BytesMut};
+use futures_core::ready;
+
+use super::{BodySize, MessageBody};
+
+/// Collects the body produced by a `MessageBody` implementation into `Bytes`.
+///
+/// Any errors produced by the body stream are returned immediately.
+///
+/// # Examples
+/// ```
+/// use actix_http::body::{self, to_bytes};
+/// use bytes::Bytes;
+///
+/// # async fn test_to_bytes() {
+/// let body = body::None::new();
+/// let bytes = to_bytes(body).await.unwrap();
+/// assert!(bytes.is_empty());
+///
+/// let body = Bytes::from_static(b"123");
+/// let bytes = to_bytes(body).await.unwrap();
+/// assert_eq!(bytes, b"123"[..]);
+/// # }
+/// ```
+pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
+    let cap = match body.size() {
+        BodySize::None | BodySize::Sized(0) => return Ok(Bytes::new()),
+        BodySize::Sized(size) => size as usize,
+        // good enough first guess for chunk size
+        BodySize::Stream => 32_768,
+    };
+
+    let mut buf = BytesMut::with_capacity(cap);
+
+    pin!(body);
+
+    poll_fn(|cx| loop {
+        let body = body.as_mut();
+
+        match ready!(body.poll_next(cx)) {
+            Some(Ok(bytes)) => buf.extend_from_slice(&*bytes),
+            None => return Poll::Ready(Ok(())),
+            Some(Err(err)) => return Poll::Ready(Err(err)),
+        }
+    })
+    .await?;
+
+    Ok(buf.freeze())
+}
+
+#[cfg(test)]
+mod test {
+    use futures_util::{stream, StreamExt as _};
+
+    use super::*;
+    use crate::{body::BodyStream, Error};
+
+    #[actix_rt::test]
+    async fn test_to_bytes() {
+        let bytes = to_bytes(()).await.unwrap();
+        assert!(bytes.is_empty());
+
+        let body = Bytes::from_static(b"123");
+        let bytes = to_bytes(body).await.unwrap();
+        assert_eq!(bytes, b"123"[..]);
+
+        let stream = stream::iter(vec![Bytes::from_static(b"123"), Bytes::from_static(b"abc")])
+            .map(Ok::<_, Error>);
+        let body = BodyStream::new(stream);
+        let bytes = to_bytes(body).await.unwrap();
+        assert_eq!(bytes, b"123abc"[..]);
+    }
+}

actix-http/src/builder.rs

@@ -1,10 +1,10 @@
-use std::{error::Error as StdError, fmt, marker::PhantomData, net, rc::Rc};
+use std::{fmt, marker::PhantomData, net, rc::Rc};
 
 use actix_codec::Framed;
 use actix_service::{IntoServiceFactory, Service, ServiceFactory};
 
 use crate::{
-    body::{AnyBody, MessageBody},
+    body::{BoxBody, MessageBody},
     config::{KeepAlive, ServiceConfig},
     h1::{self, ExpectHandler, H1Service, UpgradeHandler},
     h2::H2Service,
@@ -31,11 +31,12 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler> {
 impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::InitError: fmt::Debug,
     <S::Service as Service<Request>>::Future: 'static,
 {
     /// Create instance of `ServiceConfigBuilder`
+    #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
         HttpServiceBuilder {
             keep_alive: KeepAlive::Timeout(5),
@@ -54,11 +55,11 @@ where
 impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::InitError: fmt::Debug,
     <S::Service as Service<Request>>::Future: 'static,
     X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Error: Into<Response<AnyBody>>,
+    X::Error: Into<Response<BoxBody>>,
     X::InitError: fmt::Debug,
     U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
     U::Error: fmt::Display,
@@ -120,7 +121,7 @@ where
     where
         F: IntoServiceFactory<X1, Request>,
         X1: ServiceFactory<Request, Config = (), Response = Request>,
-        X1::Error: Into<Response<AnyBody>>,
+        X1::Error: Into<Response<BoxBody>>,
         X1::InitError: fmt::Debug,
     {
         HttpServiceBuilder {
@@ -178,7 +179,7 @@ where
     where
         B: MessageBody,
         F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Response<AnyBody>>,
+        S::Error: Into<Response<BoxBody>>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
     {
@@ -200,12 +201,11 @@ where
     pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
     where
         F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Response<AnyBody>> + 'static,
+        S::Error: Into<Response<BoxBody>> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
 
         B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,
@@ -215,20 +215,18 @@ where
             self.local_addr,
         );
 
-        H2Service::with_config(cfg, service.into_factory())
-            .on_connect_ext(self.on_connect_ext)
+        H2Service::with_config(cfg, service.into_factory()).on_connect_ext(self.on_connect_ext)
     }
 
     /// Finish service configuration and create `HttpService` instance.
     pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
     where
         F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Response<AnyBody>> + 'static,
+        S::Error: Into<Response<BoxBody>> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
 
         B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,

actix-http/src/client/mod.rs

@@ -1,26 +0,0 @@
-//! HTTP client.
-
-use http::Uri;
-
-mod config;
-mod connection;
-mod connector;
-mod error;
-mod h1proto;
-mod h2proto;
-mod pool;
-
-pub use actix_tls::connect::{
-    Connect as TcpConnect, ConnectError as TcpConnectError, Connection as TcpConnection,
-};
-
-pub use self::connection::{Connection, ConnectionIo};
-pub use self::connector::{Connector, ConnectorService};
-pub use self::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};
-pub use crate::Protocol;
-
-#[derive(Clone)]
-pub struct Connect {
-    pub uri: Uri,
-    pub addr: Option<std::net::SocketAddr>,
-}

actix-http/src/config.rs

@@ -1,26 +1,29 @@
-use std::cell::Cell;
-use std::fmt::Write;
-use std::rc::Rc;
-use std::time::Duration;
-use std::{fmt, net};
+use std::{
+    cell::Cell,
+    fmt::{self, Write},
+    net,
+    rc::Rc,
+    time::{Duration, SystemTime},
+};
 
 use actix_rt::{
     task::JoinHandle,
     time::{interval, sleep_until, Instant, Sleep},
 };
 use bytes::BytesMut;
-use time::OffsetDateTime;
 
 /// "Sun, 06 Nov 1994 08:49:37 GMT".len()
-const DATE_VALUE_LENGTH: usize = 29;
+pub(crate) const DATE_VALUE_LENGTH: usize = 29;
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 /// Server keep-alive setting
 pub enum KeepAlive {
     /// Keep alive in seconds
     Timeout(usize),
+
     /// Rely on OS to shutdown tcp connection
     Os,
+
     /// Disabled
     Disabled,
 }
@@ -104,6 +107,8 @@ impl ServiceConfig {
     }
 
     /// Returns the local address that this server is bound to.
+    ///
+    /// Returns `None` for connections via UDS (Unix Domain Socket).
     #[inline]
     pub fn local_addr(&self) -> Option<net::SocketAddr> {
         self.0.local_addr
@@ -152,8 +157,8 @@ impl ServiceConfig {
         }
     }
 
-    #[inline]
     /// Return keep-alive timer delay is configured.
+    #[inline]
     pub fn keep_alive_timer(&self) -> Option<Sleep> {
         self.keep_alive().map(|ka| sleep_until(self.now() + ka))
     }
@@ -204,12 +209,7 @@ impl Date {
 
     fn update(&mut self) {
         self.pos = 0;
-        write!(
-            self,
-            "{}",
-            OffsetDateTime::now_utc().format("%a, %d %b %Y %H:%M:%S GMT")
-        )
-        .unwrap();
+        write!(self, "{}", httpdate::fmt_http_date(SystemTime::now())).unwrap();
     }
 }
 
@@ -267,11 +267,11 @@ impl DateService {
 }
 
 // TODO: move to a util module for testing all spawn handle drop style tasks.
-#[cfg(test)]
 /// Test Module for checking the drop state of certain async tasks that are spawned
 /// with `actix_rt::spawn`
 ///
 /// The target task must explicitly generate `NotifyOnDrop` when spawn the task
+#[cfg(test)]
 mod notify_on_drop {
     use std::cell::RefCell;
 
@@ -281,9 +281,8 @@ mod notify_on_drop {
 
     /// Check if the spawned task is dropped.
     ///
-    /// # Panic:
-    ///
-    /// When there was no `NotifyOnDrop` instance on current thread
+    /// # Panics
+    /// Panics when there was no `NotifyOnDrop` instance on current thread.
     pub(crate) fn is_dropped() -> bool {
         NOTIFY_DROPPED.with(|bool| {
             bool.borrow()
@@ -326,7 +325,7 @@ mod notify_on_drop {
 mod tests {
     use super::*;
 
-    use actix_rt::task::yield_now;
+    use actix_rt::{task::yield_now, time::sleep};
 
     #[actix_rt::test]
     async fn test_date_service_update() {
@@ -350,7 +349,14 @@ mod tests {
         assert_ne!(buf1, buf2);
 
         drop(settings);
-        assert!(notify_on_drop::is_dropped());
+
+        // Ensure the task will drop eventually
+        let mut times = 0;
+        while !notify_on_drop::is_dropped() {
+            sleep(Duration::from_millis(100)).await;
+            times += 1;
+            assert!(times < 10, "Timeout waiting for task drop");
+        }
     }
 
     #[actix_rt::test]
@@ -365,14 +371,21 @@ mod tests {
         let clone3 = service.clone();
 
         drop(clone1);
-        assert_eq!(false, notify_on_drop::is_dropped());
+        assert!(!notify_on_drop::is_dropped());
         drop(clone2);
-        assert_eq!(false, notify_on_drop::is_dropped());
+        assert!(!notify_on_drop::is_dropped());
         drop(clone3);
-        assert_eq!(false, notify_on_drop::is_dropped());
+        assert!(!notify_on_drop::is_dropped());
 
         drop(service);
-        assert!(notify_on_drop::is_dropped());
+
+        // Ensure the task will drop eventually
+        let mut times = 0;
+        while !notify_on_drop::is_dropped() {
+            sleep(Duration::from_millis(100)).await;
+            times += 1;
+            assert!(times < 10, "Timeout waiting for task drop");
+        }
     }
 
     #[test]

actix-http/src/encoding/decoder.rs

@@ -8,25 +8,34 @@ use std::{
 };
 
 use actix_rt::task::{spawn_blocking, JoinHandle};
-use brotli2::write::BrotliDecoder;
 use bytes::Bytes;
-use flate2::write::{GzDecoder, ZlibDecoder};
 use futures_core::{ready, Stream};
+
+#[cfg(feature = "compress-brotli")]
+use brotli2::write::BrotliDecoder;
+
+#[cfg(feature = "compress-gzip")]
+use flate2::write::{GzDecoder, ZlibDecoder};
+
+#[cfg(feature = "compress-zstd")]
 use zstd::stream::write::Decoder as ZstdDecoder;
 
 use crate::{
     encoding::Writer,
     error::{BlockingError, PayloadError},
-    http::header::{ContentEncoding, HeaderMap, CONTENT_ENCODING},
+    header::{ContentEncoding, HeaderMap, CONTENT_ENCODING},
 };
 
 const MAX_CHUNK_SIZE_DECODE_IN_PLACE: usize = 2049;
 
-pub struct Decoder<S> {
-    decoder: Option<ContentDecoder>,
-    stream: S,
-    eof: bool,
-    fut: Option<JoinHandle<Result<(Option<Bytes>, ContentDecoder), io::Error>>>,
+pin_project_lite::pin_project! {
+    pub struct Decoder<S> {
+        decoder: Option<ContentDecoder>,
+        #[pin]
+        stream: S,
+        eof: bool,
+        fut: Option<JoinHandle<Result<(Option<Bytes>, ContentDecoder), io::Error>>>,
+    }
 }
 
 impl<S> Decoder<S>
@@ -37,15 +46,19 @@ where
     #[inline]
     pub fn new(stream: S, encoding: ContentEncoding) -> Decoder<S> {
         let decoder = match encoding {
-            ContentEncoding::Br => Some(ContentDecoder::Br(Box::new(
-                BrotliDecoder::new(Writer::new()),
-            ))),
+            #[cfg(feature = "compress-brotli")]
+            ContentEncoding::Br => Some(ContentDecoder::Br(Box::new(BrotliDecoder::new(
+                Writer::new(),
+            )))),
+            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Deflate => Some(ContentDecoder::Deflate(Box::new(
                 ZlibDecoder::new(Writer::new()),
             ))),
-            ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(
-                GzDecoder::new(Writer::new()),
-            ))),
+            #[cfg(feature = "compress-gzip")]
+            ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(GzDecoder::new(
+                Writer::new(),
+            )))),
+            #[cfg(feature = "compress-zstd")]
             ContentEncoding::Zstd => Some(ContentDecoder::Zstd(Box::new(
                 ZstdDecoder::new(Writer::new()).expect(
                     "Failed to create zstd decoder. This is a bug. \
@@ -70,7 +83,7 @@ where
         let encoding = headers
             .get(&CONTENT_ENCODING)
             .and_then(|val| val.to_str().ok())
-            .map(ContentEncoding::from)
+            .and_then(|x| x.parse().ok())
             .unwrap_or(ContentEncoding::Identity);
 
         Self::new(stream, encoding)
@@ -79,45 +92,44 @@ where
 
 impl<S> Stream for Decoder<S>
 where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
+    S: Stream<Item = Result<Bytes, PayloadError>>,
 {
     type Item = Result<Bytes, PayloadError>;
 
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut this = self.project();
+
         loop {
-            if let Some(ref mut fut) = self.fut {
+            if let Some(ref mut fut) = this.fut {
                 let (chunk, decoder) =
                     ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
 
-                self.decoder = Some(decoder);
-                self.fut.take();
+                *this.decoder = Some(decoder);
+                this.fut.take();
 
                 if let Some(chunk) = chunk {
                     return Poll::Ready(Some(Ok(chunk)));
                 }
             }
 
-            if self.eof {
+            if *this.eof {
                 return Poll::Ready(None);
             }
 
-            match ready!(Pin::new(&mut self.stream).poll_next(cx)) {
+            match ready!(this.stream.as_mut().poll_next(cx)) {
                 Some(Err(err)) => return Poll::Ready(Some(Err(err))),
 
                 Some(Ok(chunk)) => {
-                    if let Some(mut decoder) = self.decoder.take() {
+                    if let Some(mut decoder) = this.decoder.take() {
                         if chunk.len() < MAX_CHUNK_SIZE_DECODE_IN_PLACE {
                             let chunk = decoder.feed_data(chunk)?;
-                            self.decoder = Some(decoder);
+                            *this.decoder = Some(decoder);
 
                             if let Some(chunk) = chunk {
                                 return Poll::Ready(Some(Ok(chunk)));
                             }
                         } else {
-                            self.fut = Some(spawn_blocking(move || {
+                            *this.fut = Some(spawn_blocking(move || {
                                 let chunk = decoder.feed_data(chunk)?;
                                 Ok((chunk, decoder))
                             }));
@@ -130,9 +142,9 @@ where
                 }
 
                 None => {
-                    self.eof = true;
+                    *this.eof = true;
 
-                    return if let Some(mut decoder) = self.decoder.take() {
+                    return if let Some(mut decoder) = this.decoder.take() {
                         match decoder.feed_eof() {
                             Ok(Some(res)) => Poll::Ready(Some(Ok(res))),
                             Ok(None) => Poll::Ready(None),
@@ -148,17 +160,22 @@ where
 }
 
 enum ContentDecoder {
+    #[cfg(feature = "compress-gzip")]
     Deflate(Box<ZlibDecoder<Writer>>),
+    #[cfg(feature = "compress-gzip")]
     Gzip(Box<GzDecoder<Writer>>),
+    #[cfg(feature = "compress-brotli")]
     Br(Box<BrotliDecoder<Writer>>),
     // We need explicit 'static lifetime here because ZstdDecoder need lifetime
     // argument, and we use `spawn_blocking` in `Decoder::poll_next` that require `FnOnce() -> R + Send + 'static`
+    #[cfg(feature = "compress-zstd")]
     Zstd(Box<ZstdDecoder<'static, Writer>>),
 }
 
 impl ContentDecoder {
     fn feed_eof(&mut self) -> io::Result<Option<Bytes>> {
         match self {
+            #[cfg(feature = "compress-brotli")]
             ContentDecoder::Br(ref mut decoder) => match decoder.flush() {
                 Ok(()) => {
                     let b = decoder.get_mut().take();
@@ -172,6 +189,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Gzip(ref mut decoder) => match decoder.try_finish() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
@@ -185,6 +203,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Deflate(ref mut decoder) => match decoder.try_finish() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
@@ -197,6 +216,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-zstd")]
             ContentDecoder::Zstd(ref mut decoder) => match decoder.flush() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
@@ -213,6 +233,7 @@ impl ContentDecoder {
 
     fn feed_data(&mut self, data: Bytes) -> io::Result<Option<Bytes>> {
         match self {
+            #[cfg(feature = "compress-brotli")]
             ContentDecoder::Br(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
@@ -227,6 +248,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Gzip(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
@@ -241,6 +263,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Deflate(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
@@ -255,6 +278,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-zstd")]
             ContentDecoder::Zstd(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;

actix-http/src/encoding/encoder.rs

@@ -9,107 +9,113 @@ use std::{
 };
 
 use actix_rt::task::{spawn_blocking, JoinHandle};
-use brotli2::write::BrotliEncoder;
 use bytes::Bytes;
 use derive_more::Display;
-use flate2::write::{GzEncoder, ZlibEncoder};
 use futures_core::ready;
-use pin_project::pin_project;
+use pin_project_lite::pin_project;
+
+#[cfg(feature = "compress-brotli")]
+use brotli2::write::BrotliEncoder;
+
+#[cfg(feature = "compress-gzip")]
+use flate2::write::{GzEncoder, ZlibEncoder};
+
+#[cfg(feature = "compress-zstd")]
 use zstd::stream::write::Encoder as ZstdEncoder;
 
-use crate::{
-    body::{Body, BodySize, BoxAnyBody, MessageBody, ResponseBody},
-    http::{
-        header::{ContentEncoding, CONTENT_ENCODING},
-        HeaderValue, StatusCode,
-    },
-    Error, ResponseHead,
-};
-
 use super::Writer;
-use crate::error::BlockingError;
+use crate::{
+    body::{self, BodySize, MessageBody},
+    error::BlockingError,
+    header::{self, ContentEncoding, HeaderValue, CONTENT_ENCODING},
+    ResponseHead, StatusCode,
+};
 
 const MAX_CHUNK_SIZE_ENCODE_IN_PLACE: usize = 1024;
 
-#[pin_project]
-pub struct Encoder<B> {
-    eof: bool,
-    #[pin]
-    body: EncoderBody<B>,
-    encoder: Option<ContentEncoder>,
-    fut: Option<JoinHandle<Result<ContentEncoder, io::Error>>>,
+pin_project! {
+    pub struct Encoder<B> {
+        #[pin]
+        body: EncoderBody<B>,
+        encoder: Option<ContentEncoder>,
+        fut: Option<JoinHandle<Result<ContentEncoder, io::Error>>>,
+        eof: bool,
+    }
 }
 
 impl<B: MessageBody> Encoder<B> {
-    pub fn response(
-        encoding: ContentEncoding,
-        head: &mut ResponseHead,
-        body: ResponseBody<B>,
-    ) -> ResponseBody<Encoder<B>> {
+    fn none() -> Self {
+        Encoder {
+            body: EncoderBody::None {
+                body: body::None::new(),
+            },
+            encoder: None,
+            fut: None,
+            eof: true,
+        }
+    }
+
+    pub fn response(encoding: ContentEncoding, head: &mut ResponseHead, body: B) -> Self {
         let can_encode = !(head.headers().contains_key(&CONTENT_ENCODING)
             || head.status == StatusCode::SWITCHING_PROTOCOLS
             || head.status == StatusCode::NO_CONTENT
             || encoding == ContentEncoding::Identity
             || encoding == ContentEncoding::Auto);
 
-        let body = match body {
-            ResponseBody::Other(b) => match b {
-                Body::None => return ResponseBody::Other(Body::None),
-                Body::Empty => return ResponseBody::Other(Body::Empty),
-                Body::Bytes(buf) => {
-                    if can_encode {
-                        EncoderBody::Bytes(buf)
-                    } else {
-                        return ResponseBody::Other(Body::Bytes(buf));
-                    }
-                }
-                Body::Message(stream) => EncoderBody::BoxedStream(stream),
-            },
-            ResponseBody::Body(stream) => EncoderBody::Stream(stream),
+        // no need to compress an empty body
+        if matches!(body.size(), BodySize::None) {
+            return Self::none();
+        }
+
+        let body = match body.try_into_bytes() {
+            Ok(body) => EncoderBody::Full { body },
+            Err(body) => EncoderBody::Stream { body },
         };
 
         if can_encode {
-            // Modify response body only if encoder is not None
+            // Modify response body only if encoder is set
             if let Some(enc) = ContentEncoder::encoder(encoding) {
                 update_head(encoding, head);
-                head.no_chunking(false);
-                return ResponseBody::Body(Encoder {
+
+                return Encoder {
                     body,
-                    eof: false,
-                    fut: None,
                     encoder: Some(enc),
-                });
+                    fut: None,
+                    eof: false,
+                };
             }
         }
 
-        ResponseBody::Body(Encoder {
+        Encoder {
             body,
-            eof: false,
-            fut: None,
             encoder: None,
-        })
+            fut: None,
+            eof: false,
+        }
     }
 }
 
-#[pin_project(project = EncoderBodyProj)]
-enum EncoderBody<B> {
-    Bytes(Bytes),
-    Stream(#[pin] B),
-    BoxedStream(BoxAnyBody),
+pin_project! {
+    #[project = EncoderBodyProj]
+    enum EncoderBody<B> {
+        None { body: body::None },
+        Full { body: Bytes },
+        Stream { #[pin] body: B },
+    }
 }
 
 impl<B> MessageBody for EncoderBody<B>
 where
     B: MessageBody,
-    B::Error: Into<Error>,
 {
-    type Error = EncoderError<B::Error>;
+    type Error = EncoderError;
 
+    #[inline]
     fn size(&self) -> BodySize {
         match self {
-            EncoderBody::Bytes(ref b) => b.size(),
-            EncoderBody::Stream(ref b) => b.size(),
-            EncoderBody::BoxedStream(ref b) => b.size(),
+            EncoderBody::None { body } => body.size(),
+            EncoderBody::Full { body } => body.size(),
+            EncoderBody::Stream { body } => body.size(),
         }
     }
 
@@ -118,26 +124,27 @@ where
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         match self.project() {
-            EncoderBodyProj::Bytes(b) => {
-                if b.is_empty() {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(std::mem::take(b))))
-                }
+            EncoderBodyProj::None { body } => {
+                Pin::new(body).poll_next(cx).map_err(|err| match err {})
             }
-            // TODO: MSRV 1.51: poll_map_err
-            EncoderBodyProj::Stream(b) => match ready!(b.poll_next(cx)) {
-                Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Body(err)))),
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
-            EncoderBodyProj::BoxedStream(ref mut b) => {
-                match ready!(b.as_pin_mut().poll_next(cx)) {
-                    Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Boxed(err)))),
-                    Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                    None => Poll::Ready(None),
-                }
+            EncoderBodyProj::Full { body } => {
+                Pin::new(body).poll_next(cx).map_err(|err| match err {})
             }
+            EncoderBodyProj::Stream { body } => body
+                .poll_next(cx)
+                .map_err(|err| EncoderError::Body(err.into())),
+        }
+    }
+
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self>
+    where
+        Self: Sized,
+    {
+        match self {
+            EncoderBody::None { body } => Ok(body.try_into_bytes().unwrap()),
+            EncoderBody::Full { body } => Ok(body.try_into_bytes().unwrap()),
+            _ => Err(self),
         }
     }
 }
@@ -145,15 +152,15 @@ where
 impl<B> MessageBody for Encoder<B>
 where
     B: MessageBody,
-    B::Error: Into<Error>,
 {
-    type Error = EncoderError<B::Error>;
+    type Error = EncoderError;
 
+    #[inline]
     fn size(&self) -> BodySize {
-        if self.encoder.is_none() {
-            self.body.size()
-        } else {
+        if self.encoder.is_some() {
             BodySize::Stream
+        } else {
+            self.body.size()
         }
     }
 
@@ -210,6 +217,7 @@ where
                 None => {
                     if let Some(encoder) = this.encoder.take() {
                         let chunk = encoder.finish().map_err(EncoderError::Io)?;
+
                         if chunk.is_empty() {
                             return Poll::Ready(None);
                         } else {
@@ -223,42 +231,77 @@ where
             }
         }
     }
+
+    #[inline]
+    fn try_into_bytes(mut self) -> Result<Bytes, Self>
+    where
+        Self: Sized,
+    {
+        if self.encoder.is_some() {
+            Err(self)
+        } else {
+            match self.body.try_into_bytes() {
+                Ok(body) => Ok(body),
+                Err(body) => {
+                    self.body = body;
+                    Err(self)
+                }
+            }
+        }
+    }
 }
 
 fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
     head.headers_mut().insert(
-        CONTENT_ENCODING,
+        header::CONTENT_ENCODING,
         HeaderValue::from_static(encoding.as_str()),
     );
+
+    head.no_chunking(false);
 }
 
 enum ContentEncoder {
+    #[cfg(feature = "compress-gzip")]
     Deflate(ZlibEncoder<Writer>),
+
+    #[cfg(feature = "compress-gzip")]
     Gzip(GzEncoder<Writer>),
+
+    #[cfg(feature = "compress-brotli")]
     Br(BrotliEncoder<Writer>),
-    // We need explicit 'static lifetime here because ZstdEncoder need lifetime
-    // argument, and we use `spawn_blocking` in `Encoder::poll_next` that require `FnOnce() -> R + Send + 'static`
+
+    // Wwe need explicit 'static lifetime here because ZstdEncoder needs a lifetime argument and we
+    // use `spawn_blocking` in `Encoder::poll_next` that requires `FnOnce() -> R + Send + 'static`.
+    #[cfg(feature = "compress-zstd")]
     Zstd(ZstdEncoder<'static, Writer>),
 }
 
 impl ContentEncoder {
     fn encoder(encoding: ContentEncoding) -> Option<Self> {
         match encoding {
+            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Deflate => Some(ContentEncoder::Deflate(ZlibEncoder::new(
                 Writer::new(),
                 flate2::Compression::fast(),
             ))),
+
+            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Gzip => Some(ContentEncoder::Gzip(GzEncoder::new(
                 Writer::new(),
                 flate2::Compression::fast(),
             ))),
+
+            #[cfg(feature = "compress-brotli")]
             ContentEncoding::Br => {
                 Some(ContentEncoder::Br(BrotliEncoder::new(Writer::new(), 3)))
             }
+
+            #[cfg(feature = "compress-zstd")]
             ContentEncoding::Zstd => {
                 let encoder = ZstdEncoder::new(Writer::new(), 3).ok()?;
                 Some(ContentEncoder::Zstd(encoder))
             }
+
             _ => None,
         }
     }
@@ -266,27 +309,41 @@ impl ContentEncoder {
     #[inline]
     pub(crate) fn take(&mut self) -> Bytes {
         match *self {
+            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(ref mut encoder) => encoder.get_mut().take(),
+
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(ref mut encoder) => encoder.get_mut().take(),
+
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(ref mut encoder) => encoder.get_mut().take(),
+
+            #[cfg(feature = "compress-zstd")]
             ContentEncoder::Zstd(ref mut encoder) => encoder.get_mut().take(),
         }
     }
 
     fn finish(self) -> Result<Bytes, io::Error> {
         match self {
+            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
+
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
+
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
+
+            #[cfg(feature = "compress-zstd")]
             ContentEncoder::Zstd(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
@@ -296,6 +353,7 @@ impl ContentEncoder {
 
     fn write(&mut self, data: &[u8]) -> Result<(), io::Error> {
         match *self {
+            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -303,6 +361,8 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
+
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -310,6 +370,8 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
+
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -317,6 +379,8 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
+
+            #[cfg(feature = "compress-zstd")]
             ContentEncoder::Zstd(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -330,12 +394,9 @@ impl ContentEncoder {
 
 #[derive(Debug, Display)]
 #[non_exhaustive]
-pub enum EncoderError<E> {
+pub enum EncoderError {
     #[display(fmt = "body")]
-    Body(E),
-
-    #[display(fmt = "boxed")]
-    Boxed(Box<dyn StdError>),
+    Body(Box<dyn StdError>),
 
     #[display(fmt = "blocking")]
     Blocking(BlockingError),
@@ -344,19 +405,18 @@ pub enum EncoderError<E> {
     Io(io::Error),
 }
 
-impl<E: StdError + 'static> StdError for EncoderError<E> {
+impl StdError for EncoderError {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
         match self {
-            EncoderError::Body(err) => Some(err),
-            EncoderError::Boxed(err) => Some(&**err),
+            EncoderError::Body(err) => Some(&**err),
             EncoderError::Blocking(err) => Some(err),
             EncoderError::Io(err) => Some(err),
         }
     }
 }
 
-impl<E: StdError + 'static> From<EncoderError<E>> for crate::Error {
-    fn from(err: EncoderError<E>) -> Self {
+impl From<EncoderError> for crate::Error {
+    fn from(err: EncoderError) -> Self {
         crate::Error::new_encoder().with_cause(err)
     }
 }

actix-http/src/encoding/mod.rs

@@ -10,6 +10,9 @@ mod encoder;
 pub use self::decoder::Decoder;
 pub use self::encoder::Encoder;
 
+/// Special-purpose writer for streaming (de-)compression.
+///
+/// Pre-allocates 8KiB of capacity.
 pub(self) struct Writer {
     buf: BytesMut,
 }

actix-http/src/error.rs

@@ -5,10 +5,7 @@ use std::{error::Error as StdError, fmt, io, str::Utf8Error, string::FromUtf8Err
 use derive_more::{Display, Error, From};
 use http::{uri::InvalidUri, StatusCode};
 
-use crate::{
-    body::{AnyBody, Body},
-    ws, Response,
-};
+use crate::{body::BoxBody, ws, Response};
 
 pub use http::Error as HttpError;
 
@@ -29,6 +26,11 @@ impl Error {
         }
     }
 
+    pub(crate) fn with_cause(mut self, cause: impl Into<Box<dyn StdError>>) -> Self {
+        self.inner.cause = Some(cause.into());
+        self
+    }
+
     pub(crate) fn new_http() -> Self {
         Self::new(Kind::Http)
     }
@@ -49,12 +51,12 @@ impl Error {
         Self::new(Kind::SendResponse)
     }
 
-    // TODO: remove allow
-    #[allow(dead_code)]
+    #[allow(unused)] // reserved for future use (TODO: remove allow when being used)
     pub(crate) fn new_io() -> Self {
         Self::new(Kind::Io)
     }
 
+    #[allow(unused)] // used in encoder behind feature flag so ignore unused warning
     pub(crate) fn new_encoder() -> Self {
         Self::new(Kind::Encoder)
     }
@@ -62,26 +64,22 @@ impl Error {
     pub(crate) fn new_ws() -> Self {
         Self::new(Kind::Ws)
     }
-
-    pub(crate) fn with_cause(mut self, cause: impl Into<Box<dyn StdError>>) -> Self {
-        self.inner.cause = Some(cause.into());
-        self
-    }
 }
 
-impl From<Error> for Response<AnyBody> {
+impl From<Error> for Response<BoxBody> {
     fn from(err: Error) -> Self {
+        // TODO: more appropriate error status codes, usage assessment needed
         let status_code = match err.inner.kind {
             Kind::Parse => StatusCode::BAD_REQUEST,
             _ => StatusCode::INTERNAL_SERVER_ERROR,
         };
 
-        Response::new(status_code).set_body(Body::from(err.to_string()))
+        Response::new(status_code).set_body(BoxBody::new(err.to_string()))
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Display)]
-pub enum Kind {
+pub(crate) enum Kind {
     #[display(fmt = "error processing HTTP")]
     Http,
 
@@ -125,7 +123,7 @@ impl fmt::Display for Error {
 
 impl StdError for Error {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        self.inner.cause.as_ref().map(|err| err.as_ref())
+        self.inner.cause.as_ref().map(Box::as_ref)
     }
 }
 
@@ -135,12 +133,6 @@ impl From<std::convert::Infallible> for Error {
     }
 }
 
-impl From<ws::ProtocolError> for Error {
-    fn from(err: ws::ProtocolError) -> Self {
-        Self::new_ws().with_cause(err)
-    }
-}
-
 impl From<HttpError> for Error {
     fn from(err: HttpError) -> Self {
         Self::new_http().with_cause(err)
@@ -153,6 +145,12 @@ impl From<ws::HandshakeError> for Error {
     }
 }
 
+impl From<ws::ProtocolError> for Error {
+    fn from(err: ws::ProtocolError) -> Self {
+        Self::new_ws().with_cause(err)
+    }
+}
+
 /// A set of errors that can occur during parsing HTTP streams.
 #[derive(Debug, Display, Error)]
 #[non_exhaustive]
@@ -194,7 +192,7 @@ pub enum ParseError {
     #[display(fmt = "IO error: {}", _0)]
     Io(io::Error),
 
-    /// Parsing a field as string failed
+    /// Parsing a field as string failed.
     #[display(fmt = "UTF8 error: {}", _0)]
     Utf8(Utf8Error),
 }
@@ -243,7 +241,7 @@ impl From<ParseError> for Error {
     }
 }
 
-impl From<ParseError> for Response<AnyBody> {
+impl From<ParseError> for Response<BoxBody> {
     fn from(err: ParseError) -> Self {
         Error::from(err).into()
     }
@@ -334,31 +332,28 @@ impl From<PayloadError> for Error {
 }
 
 /// A set of errors that can occur during dispatching HTTP requests.
-#[derive(Debug, Display, Error, From)]
-#[non_exhaustive]
+#[derive(Debug, Display, From)]
 pub enum DispatchError {
-    /// Service error
-    // FIXME: display and error type
+    /// Service error.
     #[display(fmt = "Service Error")]
-    Service(#[error(not(source))] Response<AnyBody>),
+    Service(Response<BoxBody>),
 
-    /// Body error
-    // FIXME: display and error type
-    #[display(fmt = "Body Error")]
-    Body(#[error(not(source))] Box<dyn StdError>),
+    /// Body streaming error.
+    #[display(fmt = "Body error: {}", _0)]
+    Body(Box<dyn StdError>),
 
-    /// Upgrade service error
+    /// Upgrade service error.
     Upgrade,
 
     /// An `io::Error` that occurred while trying to read or write to a network stream.
     #[display(fmt = "IO error: {}", _0)]
     Io(io::Error),
 
-    /// Http request parse error.
-    #[display(fmt = "Parse error: {}", _0)]
+    /// Request parse error.
+    #[display(fmt = "Request parse error: {}", _0)]
     Parse(ParseError),
 
-    /// Http/2 error
+    /// HTTP/2 error.
     #[display(fmt = "{}", _0)]
     H2(h2::Error),
 
@@ -370,21 +365,23 @@ pub enum DispatchError {
     #[display(fmt = "Connection shutdown timeout")]
     DisconnectTimeout,
 
-    /// Payload is not consumed
-    #[display(fmt = "Task is completed but request's payload is not consumed")]
-    PayloadIsNotConsumed,
-
-    /// Malformed request
-    #[display(fmt = "Malformed request")]
-    MalformedRequest,
-
-    /// Internal error
+    /// Internal error.
     #[display(fmt = "Internal error")]
     InternalError,
+}
 
-    /// Unknown error
-    #[display(fmt = "Unknown error")]
-    Unknown,
+impl StdError for DispatchError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        match self {
+            // TODO: error source extraction?
+            DispatchError::Service(_res) => None,
+            DispatchError::Body(err) => Some(&**err),
+            DispatchError::Io(err) => Some(err),
+            DispatchError::Parse(err) => Some(err),
+            DispatchError::H2(err) => Some(err),
+            _ => None,
+        }
+    }
 }
 
 /// A set of error that can occur during parsing content type.
@@ -424,11 +421,11 @@ mod tests {
 
     #[test]
     fn test_into_response() {
-        let resp: Response<AnyBody> = ParseError::Incomplete.into();
+        let resp: Response<BoxBody> = ParseError::Incomplete.into();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 
         let err: HttpError = StatusCode::from_u16(10000).err().unwrap().into();
-        let resp: Response<AnyBody> = Error::new_http().with_cause(err).into();
+        let resp: Response<BoxBody> = Error::new_http().with_cause(err).into();
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
@@ -453,14 +450,13 @@ mod tests {
     fn test_error_http_response() {
         let orig = io::Error::new(io::ErrorKind::Other, "other");
         let err = Error::new_io().with_cause(orig);
-        let resp: Response<AnyBody> = err.into();
+        let resp: Response<BoxBody> = err.into();
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
     #[test]
     fn test_payload_error() {
-        let err: PayloadError =
-            io::Error::new(io::ErrorKind::Other, "ParseError").into();
+        let err: PayloadError = io::Error::new(io::ErrorKind::Other, "ParseError").into();
         assert!(err.to_string().contains("ParseError"));
 
         let err = PayloadError::Incomplete(None);

actix-http/src/extensions.rs

@@ -1,6 +1,6 @@
 use std::{
     any::{Any, TypeId},
-    fmt, mem,
+    fmt,
 };
 
 use ahash::AHashMap;
@@ -10,8 +10,7 @@ use ahash::AHashMap;
 /// All entries into this map must be owned types (or static references).
 #[derive(Default)]
 pub struct Extensions {
-    /// Use FxHasher with a std HashMap with for faster
-    /// lookups on the small `TypeId` (u64 equivalent) keys.
+    /// Use AHasher with a std HashMap with for faster lookups on the small `TypeId` keys.
     map: AHashMap<TypeId, Box<dyn Any>>,
 }
 
@@ -20,7 +19,7 @@ impl Extensions {
     #[inline]
     pub fn new() -> Extensions {
         Extensions {
-            map: AHashMap::default(),
+            map: AHashMap::new(),
         }
     }
 
@@ -123,11 +122,6 @@ impl Extensions {
     pub fn extend(&mut self, other: Extensions) {
         self.map.extend(other.map);
     }
-
-    /// Sets (or overrides) items from `other` into this map.
-    pub(crate) fn drain_from(&mut self, other: &mut Self) {
-        self.map.extend(mem::take(&mut other.map));
-    }
 }
 
 impl fmt::Debug for Extensions {
@@ -179,6 +173,8 @@ mod tests {
 
     #[test]
     fn test_integers() {
+        static A: u32 = 8;
+
         let mut map = Extensions::new();
 
         map.insert::<i8>(8);
@@ -191,6 +187,7 @@ mod tests {
         map.insert::<u32>(32);
         map.insert::<u64>(64);
         map.insert::<u128>(128);
+        map.insert::<&'static u32>(&A);
         assert!(map.get::<i8>().is_some());
         assert!(map.get::<i16>().is_some());
         assert!(map.get::<i32>().is_some());
@@ -201,6 +198,7 @@ mod tests {
         assert!(map.get::<u32>().is_some());
         assert!(map.get::<u64>().is_some());
         assert!(map.get::<u128>().is_some());
+        assert!(map.get::<&'static u32>().is_some());
     }
 
     #[test]
@@ -279,27 +277,4 @@ mod tests {
         assert_eq!(extensions.get(), Some(&20u8));
         assert_eq!(extensions.get_mut(), Some(&mut 20u8));
     }
-
-    #[test]
-    fn test_drain_from() {
-        let mut ext = Extensions::new();
-        ext.insert(2isize);
-
-        let mut more_ext = Extensions::new();
-
-        more_ext.insert(5isize);
-        more_ext.insert(5usize);
-
-        assert_eq!(ext.get::<isize>(), Some(&2isize));
-        assert_eq!(ext.get::<usize>(), None);
-        assert_eq!(more_ext.get::<isize>(), Some(&5isize));
-        assert_eq!(more_ext.get::<usize>(), Some(&5usize));
-
-        ext.drain_from(&mut more_ext);
-
-        assert_eq!(ext.get::<isize>(), Some(&5isize));
-        assert_eq!(ext.get::<usize>(), Some(&5usize));
-        assert_eq!(more_ext.get::<isize>(), None);
-        assert_eq!(more_ext.get::<usize>(), None);
-    }
 }

actix-http/src/h1/chunked.rs

@@ -0,0 +1,426 @@
+use std::{io, task::Poll};
+
+use bytes::{Buf as _, Bytes, BytesMut};
+
+macro_rules! byte (
+    ($rdr:ident) => ({
+        if $rdr.len() > 0 {
+            let b = $rdr[0];
+            $rdr.advance(1);
+            b
+        } else {
+            return Poll::Pending
+        }
+    })
+);
+
+#[derive(Debug, PartialEq, Clone)]
+pub(super) enum ChunkedState {
+    Size,
+    SizeLws,
+    Extension,
+    SizeLf,
+    Body,
+    BodyCr,
+    BodyLf,
+    EndCr,
+    EndLf,
+    End,
+}
+
+impl ChunkedState {
+    pub(super) fn step(
+        &self,
+        body: &mut BytesMut,
+        size: &mut u64,
+        buf: &mut Option<Bytes>,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        use self::ChunkedState::*;
+        match *self {
+            Size => ChunkedState::read_size(body, size),
+            SizeLws => ChunkedState::read_size_lws(body),
+            Extension => ChunkedState::read_extension(body),
+            SizeLf => ChunkedState::read_size_lf(body, *size),
+            Body => ChunkedState::read_body(body, size, buf),
+            BodyCr => ChunkedState::read_body_cr(body),
+            BodyLf => ChunkedState::read_body_lf(body),
+            EndCr => ChunkedState::read_end_cr(body),
+            EndLf => ChunkedState::read_end_lf(body),
+            End => Poll::Ready(Ok(ChunkedState::End)),
+        }
+    }
+
+    fn read_size(rdr: &mut BytesMut, size: &mut u64) -> Poll<Result<ChunkedState, io::Error>> {
+        let radix = 16;
+
+        let rem = match byte!(rdr) {
+            b @ b'0'..=b'9' => b - b'0',
+            b @ b'a'..=b'f' => b + 10 - b'a',
+            b @ b'A'..=b'F' => b + 10 - b'A',
+            b'\t' | b' ' => return Poll::Ready(Ok(ChunkedState::SizeLws)),
+            b';' => return Poll::Ready(Ok(ChunkedState::Extension)),
+            b'\r' => return Poll::Ready(Ok(ChunkedState::SizeLf)),
+            _ => {
+                return Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "Invalid chunk size line: Invalid Size",
+                )));
+            }
+        };
+
+        match size.checked_mul(radix) {
+            Some(n) => {
+                *size = n as u64;
+                *size += rem as u64;
+
+                Poll::Ready(Ok(ChunkedState::Size))
+            }
+            None => {
+                log::debug!("chunk size would overflow u64");
+                Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "Invalid chunk size line: Size is too big",
+                )))
+            }
+        }
+    }
+
+    fn read_size_lws(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            // LWS can follow the chunk size, but no more digits can come
+            b'\t' | b' ' => Poll::Ready(Ok(ChunkedState::SizeLws)),
+            b';' => Poll::Ready(Ok(ChunkedState::Extension)),
+            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk size linear white space",
+            ))),
+        }
+    }
+    fn read_extension(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
+            // strictly 0x20 (space) should be disallowed but we don't parse quoted strings here
+            0x00..=0x08 | 0x0a..=0x1f | 0x7f => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid character in chunk extension",
+            ))),
+            _ => Poll::Ready(Ok(ChunkedState::Extension)), // no supported extensions
+        }
+    }
+    fn read_size_lf(rdr: &mut BytesMut, size: u64) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\n' if size > 0 => Poll::Ready(Ok(ChunkedState::Body)),
+            b'\n' if size == 0 => Poll::Ready(Ok(ChunkedState::EndCr)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk size LF",
+            ))),
+        }
+    }
+
+    fn read_body(
+        rdr: &mut BytesMut,
+        rem: &mut u64,
+        buf: &mut Option<Bytes>,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        log::trace!("Chunked read, remaining={:?}", rem);
+
+        let len = rdr.len() as u64;
+        if len == 0 {
+            Poll::Ready(Ok(ChunkedState::Body))
+        } else {
+            let slice;
+            if *rem > len {
+                slice = rdr.split().freeze();
+                *rem -= len;
+            } else {
+                slice = rdr.split_to(*rem as usize).freeze();
+                *rem = 0;
+            }
+            *buf = Some(slice);
+            if *rem > 0 {
+                Poll::Ready(Ok(ChunkedState::Body))
+            } else {
+                Poll::Ready(Ok(ChunkedState::BodyCr))
+            }
+        }
+    }
+
+    fn read_body_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::BodyLf)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk body CR",
+            ))),
+        }
+    }
+    fn read_body_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\n' => Poll::Ready(Ok(ChunkedState::Size)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk body LF",
+            ))),
+        }
+    }
+    fn read_end_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::EndLf)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk end CR",
+            ))),
+        }
+    }
+    fn read_end_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\n' => Poll::Ready(Ok(ChunkedState::End)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk end LF",
+            ))),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use actix_codec::Decoder as _;
+    use bytes::{Bytes, BytesMut};
+    use http::Method;
+
+    use crate::{
+        error::ParseError,
+        h1::decoder::{MessageDecoder, PayloadItem},
+        HttpMessage as _, Request,
+    };
+
+    macro_rules! parse_ready {
+        ($e:expr) => {{
+            match MessageDecoder::<Request>::default().decode($e) {
+                Ok(Some((msg, _))) => msg,
+                Ok(_) => unreachable!("Eof during parsing http request"),
+                Err(err) => unreachable!("Error during parsing http request: {:?}", err),
+            }
+        }};
+    }
+
+    macro_rules! expect_parse_err {
+        ($e:expr) => {{
+            match MessageDecoder::<Request>::default().decode($e) {
+                Err(err) => match err {
+                    ParseError::Io(_) => unreachable!("Parse error expected"),
+                    _ => {}
+                },
+                _ => unreachable!("Error expected"),
+            }
+        }};
+    }
+
+    #[test]
+    fn test_parse_chunked_payload_chunk_extension() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+            transfer-encoding: chunked\r\n\
+            \r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+        assert!(msg.chunked().unwrap());
+
+        buf.extend(b"4;test\r\ndata\r\n4\r\nline\r\n0\r\n\r\n"); // test: test\r\n\r\n")
+        let chunk = pl.decode(&mut buf).unwrap().unwrap().chunk();
+        assert_eq!(chunk, Bytes::from_static(b"data"));
+        let chunk = pl.decode(&mut buf).unwrap().unwrap().chunk();
+        assert_eq!(chunk, Bytes::from_static(b"line"));
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert!(msg.eof());
+    }
+
+    #[test]
+    fn test_request_chunked() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+        let req = parse_ready!(&mut buf);
+
+        if let Ok(val) = req.chunked() {
+            assert!(val);
+        } else {
+            unreachable!("Error");
+        }
+
+        // intentional typo in "chunked"
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chnked\r\n\r\n",
+        );
+        expect_parse_err!(&mut buf);
+    }
+
+    #[test]
+    fn test_http_request_chunked_payload() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+        assert!(req.chunked().unwrap());
+
+        buf.extend(b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n");
+        assert_eq!(
+            pl.decode(&mut buf).unwrap().unwrap().chunk().as_ref(),
+            b"data"
+        );
+        assert_eq!(
+            pl.decode(&mut buf).unwrap().unwrap().chunk().as_ref(),
+            b"line"
+        );
+        assert!(pl.decode(&mut buf).unwrap().unwrap().eof());
+    }
+
+    #[test]
+    fn test_http_request_chunked_payload_and_next_message() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+        assert!(req.chunked().unwrap());
+
+        buf.extend(
+            b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n\
+              POST /test2 HTTP/1.1\r\n\
+              transfer-encoding: chunked\r\n\r\n"
+                .iter(),
+        );
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"data");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"line");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert!(msg.eof());
+
+        let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
+        assert!(req.chunked().unwrap());
+        assert_eq!(*req.method(), Method::POST);
+        assert!(req.chunked().unwrap());
+    }
+
+    #[test]
+    fn test_http_request_chunked_payload_chunks() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+        assert!(req.chunked().unwrap());
+
+        buf.extend(b"4\r\n1111\r\n");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"1111");
+
+        buf.extend(b"4\r\ndata\r");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"data");
+
+        buf.extend(b"\n4");
+        assert!(pl.decode(&mut buf).unwrap().is_none());
+
+        buf.extend(b"\r");
+        assert!(pl.decode(&mut buf).unwrap().is_none());
+        buf.extend(b"\n");
+        assert!(pl.decode(&mut buf).unwrap().is_none());
+
+        buf.extend(b"li");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"li");
+
+        //trailers
+        //buf.feed_data("test: test\r\n");
+        //not_ready!(reader.parse(&mut buf, &mut readbuf));
+
+        buf.extend(b"ne\r\n0\r\n");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"ne");
+        assert!(pl.decode(&mut buf).unwrap().is_none());
+
+        buf.extend(b"\r\n");
+        assert!(pl.decode(&mut buf).unwrap().unwrap().eof());
+    }
+
+    #[test]
+    fn chunk_extension_quoted() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+            Host: localhost:8080\r\n\
+            Transfer-Encoding: chunked\r\n\
+            \r\n\
+            2;hello=b;one=\"1 2 3\"\r\n\
+            xx",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+
+        let chunk = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(chunk, PayloadItem::Chunk(Bytes::from_static(b"xx")));
+    }
+
+    #[test]
+    fn hrs_chunk_extension_invalid() {
+        let mut buf = BytesMut::from(
+            "GET / HTTP/1.1\r\n\
+            Host: localhost:8080\r\n\
+            Transfer-Encoding: chunked\r\n\
+            \r\n\
+            2;x\nx\r\n\
+            4c\r\n\
+            0\r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+
+        let err = pl.decode(&mut buf).unwrap_err();
+        assert!(err
+            .to_string()
+            .contains("Invalid character in chunk extension"));
+    }
+
+    #[test]
+    fn hrs_chunk_size_overflow() {
+        let mut buf = BytesMut::from(
+            "GET / HTTP/1.1\r\n\
+            Host: example.com\r\n\
+            Transfer-Encoding: chunked\r\n\
+            \r\n\
+            f0000000000000003\r\n\
+            abc\r\n\
+            0\r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+
+        let err = pl.decode(&mut buf).unwrap_err();
+        assert!(err
+            .to_string()
+            .contains("Invalid chunk size line: Size is too big"));
+    }
+}

actix-http/src/h1/client.rs

@@ -5,13 +5,15 @@ use bitflags::bitflags;
 use bytes::{Bytes, BytesMut};
 use http::{Method, Version};
 
-use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
-use super::{decoder, encoder, reserve_readbuf};
-use super::{Message, MessageType};
-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::error::{ParseError, PayloadError};
-use crate::message::{ConnectionType, RequestHeadType, ResponseHead};
+use super::{
+    decoder::{self, PayloadDecoder, PayloadItem, PayloadType},
+    encoder, reserve_readbuf, Message, MessageType,
+};
+use crate::{
+    body::BodySize,
+    error::{ParseError, PayloadError},
+    ConnectionType, RequestHeadType, ResponseHead, ServiceConfig,
+};
 
 bitflags! {
     struct Flags: u8 {
@@ -120,7 +122,7 @@ impl Decoder for ClientCodec {
         debug_assert!(!self.inner.payload.is_some(), "Payload decoder is set");
 
         if let Some((req, payload)) = self.inner.decoder.decode(src)? {
-            if let Some(ctype) = req.ctype() {
+            if let Some(ctype) = req.conn_type() {
                 // do not use peer's keep-alive
                 self.inner.ctype = if ctype == ConnectionType::KeepAlive {
                     self.inner.ctype

actix-http/src/h1/codec.rs

@@ -5,15 +5,13 @@ use bitflags::bitflags;
 use bytes::BytesMut;
 use http::{Method, Version};
 
-use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
-use super::{decoder, encoder};
-use super::{Message, MessageType};
-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::error::ParseError;
-use crate::message::ConnectionType;
-use crate::request::Request;
-use crate::response::Response;
+use super::{
+    decoder::{self, PayloadDecoder, PayloadItem, PayloadType},
+    encoder, Message, MessageType,
+};
+use crate::{
+    body::BodySize, error::ParseError, ConnectionType, Request, Response, ServiceConfig,
+};
 
 bitflags! {
     struct Flags: u8 {
@@ -29,7 +27,7 @@ pub struct Codec {
     decoder: decoder::MessageDecoder<Request>,
     payload: Option<PayloadDecoder>,
     version: Version,
-    ctype: ConnectionType,
+    conn_type: ConnectionType,
 
     // encoder part
     flags: Flags,
@@ -65,7 +63,7 @@ impl Codec {
             decoder: decoder::MessageDecoder::default(),
             payload: None,
             version: Version::HTTP_11,
-            ctype: ConnectionType::Close,
+            conn_type: ConnectionType::Close,
             encoder: encoder::MessageEncoder::default(),
         }
     }
@@ -73,13 +71,13 @@ impl Codec {
     /// Check if request is upgrade.
     #[inline]
     pub fn upgrade(&self) -> bool {
-        self.ctype == ConnectionType::Upgrade
+        self.conn_type == ConnectionType::Upgrade
     }
 
     /// Check if last response is keep-alive.
     #[inline]
     pub fn keepalive(&self) -> bool {
-        self.ctype == ConnectionType::KeepAlive
+        self.conn_type == ConnectionType::KeepAlive
     }
 
     /// Check if keep-alive enabled on server level.
@@ -124,11 +122,11 @@ impl Decoder for Codec {
             let head = req.head();
             self.flags.set(Flags::HEAD, head.method == Method::HEAD);
             self.version = head.version;
-            self.ctype = head.connection_type();
-            if self.ctype == ConnectionType::KeepAlive
+            self.conn_type = head.connection_type();
+            if self.conn_type == ConnectionType::KeepAlive
                 && !self.flags.contains(Flags::KEEPALIVE_ENABLED)
             {
-                self.ctype = ConnectionType::Close
+                self.conn_type = ConnectionType::Close
             }
             match payload {
                 PayloadType::None => self.payload = None,
@@ -159,14 +157,14 @@ impl Encoder<Message<(Response<()>, BodySize)>> for Codec {
                 res.head_mut().version = self.version;
 
                 // connection status
-                self.ctype = if let Some(ct) = res.head().ctype() {
+                self.conn_type = if let Some(ct) = res.head().conn_type() {
                     if ct == ConnectionType::KeepAlive {
-                        self.ctype
+                        self.conn_type
                     } else {
                         ct
                     }
                 } else {
-                    self.ctype
+                    self.conn_type
                 };
 
                 // encode message
@@ -177,10 +175,9 @@ impl Encoder<Message<(Response<()>, BodySize)>> for Codec {
                     self.flags.contains(Flags::STREAM),
                     self.version,
                     length,
-                    self.ctype,
+                    self.conn_type,
                     &self.config,
                 )?;
-                // self.headers_size = (dst.len() - len) as u32;
             }
             Message::Chunk(Some(bytes)) => {
                 self.encoder.encode_chunk(bytes.as_ref(), dst)?;
@@ -189,6 +186,7 @@ impl Encoder<Message<(Response<()>, BodySize)>> for Codec {
                 self.encoder.encode_eof(dst)?;
             }
         }
+
         Ok(())
     }
 }
@@ -199,7 +197,7 @@ mod tests {
     use http::Method;
 
     use super::*;
-    use crate::HttpMessage;
+    use crate::HttpMessage as _;
 
     #[actix_rt::test]
     async fn test_http_request_chunked_payload_and_next_message() {

actix-http/src/h1/decoder.rs

@@ -1,18 +1,15 @@
-use std::convert::TryFrom;
-use std::io;
-use std::marker::PhantomData;
-use std::task::Poll;
+use std::{convert::TryFrom, io, marker::PhantomData, mem::MaybeUninit, task::Poll};
 
 use actix_codec::Decoder;
-use bytes::{Buf, Bytes, BytesMut};
-use http::header::{HeaderName, HeaderValue};
-use http::{header, Method, StatusCode, Uri, Version};
+use bytes::{Bytes, BytesMut};
+use http::{
+    header::{self, HeaderName, HeaderValue},
+    Method, StatusCode, Uri, Version,
+};
 use log::{debug, error, trace};
 
-use crate::error::ParseError;
-use crate::header::HeaderMap;
-use crate::message::{ConnectionType, ResponseHead};
-use crate::request::Request;
+use super::chunked::ChunkedState;
+use crate::{error::ParseError, header::HeaderMap, ConnectionType, Request, ResponseHead};
 
 pub(crate) const MAX_BUFFER_SIZE: usize = 131_072;
 const MAX_HEADERS: usize = 96;
@@ -50,7 +47,7 @@ pub(crate) enum PayloadLength {
 }
 
 pub(crate) trait MessageType: Sized {
-    fn set_connection_type(&mut self, ctype: Option<ConnectionType>);
+    fn set_connection_type(&mut self, conn_type: Option<ConnectionType>);
 
     fn set_expect(&mut self);
 
@@ -67,14 +64,14 @@ pub(crate) trait MessageType: Sized {
         let mut has_upgrade_websocket = false;
         let mut expect = false;
         let mut chunked = false;
+        let mut seen_te = false;
         let mut content_length = None;
 
         {
             let headers = self.headers_mut();
 
             for idx in raw_headers.iter() {
-                let name =
-                    HeaderName::from_bytes(&slice[idx.name.0..idx.name.1]).unwrap();
+                let name = HeaderName::from_bytes(&slice[idx.name.0..idx.name.1]).unwrap();
 
                 // SAFETY: httparse already checks header value is only visible ASCII bytes
                 // from_maybe_shared_unchecked contains debug assertions so they are omitted here
@@ -85,8 +82,17 @@ pub(crate) trait MessageType: Sized {
                 };
 
                 match name {
-                    header::CONTENT_LENGTH => {
-                        if let Ok(s) = value.to_str() {
+                    header::CONTENT_LENGTH if content_length.is_some() => {
+                        debug!("multiple Content-Length");
+                        return Err(ParseError::Header);
+                    }
+
+                    header::CONTENT_LENGTH => match value.to_str() {
+                        Ok(s) if s.trim().starts_with('+') => {
+                            debug!("illegal Content-Length: {:?}", s);
+                            return Err(ParseError::Header);
+                        }
+                        Ok(s) => {
                             if let Ok(len) = s.parse::<u64>() {
                                 if len != 0 {
                                     content_length = Some(len);
@@ -95,22 +101,38 @@ pub(crate) trait MessageType: Sized {
                                 debug!("illegal Content-Length: {:?}", s);
                                 return Err(ParseError::Header);
                             }
-                        } else {
+                        }
+                        Err(_) => {
                             debug!("illegal Content-Length: {:?}", value);
                             return Err(ParseError::Header);
                         }
-                    }
+                    },
+
                     // transfer-encoding
+                    header::TRANSFER_ENCODING if seen_te => {
+                        debug!("multiple Transfer-Encoding not allowed");
+                        return Err(ParseError::Header);
+                    }
+
                     header::TRANSFER_ENCODING => {
-                        if let Ok(s) = value.to_str().map(|s| s.trim()) {
-                            chunked = s.eq_ignore_ascii_case("chunked");
+                        seen_te = true;
+
+                        if let Ok(s) = value.to_str().map(str::trim) {
+                            if s.eq_ignore_ascii_case("chunked") {
+                                chunked = true;
+                            } else if s.eq_ignore_ascii_case("identity") {
+                                // allow silently since multiple TE headers are already checked
+                            } else {
+                                debug!("illegal Transfer-Encoding: {:?}", s);
+                                return Err(ParseError::Header);
+                            }
                         } else {
                             return Err(ParseError::Header);
                         }
                     }
                     // connection keep-alive state
                     header::CONNECTION => {
-                        ka = if let Ok(conn) = value.to_str().map(|conn| conn.trim()) {
+                        ka = if let Ok(conn) = value.to_str().map(str::trim) {
                             if conn.eq_ignore_ascii_case("keep-alive") {
                                 Some(ConnectionType::KeepAlive)
                             } else if conn.eq_ignore_ascii_case("close") {
@@ -125,7 +147,7 @@ pub(crate) trait MessageType: Sized {
                         };
                     }
                     header::UPGRADE => {
-                        if let Ok(val) = value.to_str().map(|val| val.trim()) {
+                        if let Ok(val) = value.to_str().map(str::trim) {
                             if val.eq_ignore_ascii_case("websocket") {
                                 has_upgrade_websocket = true;
                             }
@@ -148,7 +170,7 @@ pub(crate) trait MessageType: Sized {
             self.set_expect()
         }
 
-        // https://tools.ietf.org/html/rfc7230#section-3.3.3
+        // https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.3
         if chunked {
             // Chunked encoding
             Ok(PayloadLength::Payload(PayloadType::Payload(
@@ -168,8 +190,8 @@ pub(crate) trait MessageType: Sized {
 }
 
 impl MessageType for Request {
-    fn set_connection_type(&mut self, ctype: Option<ConnectionType>) {
-        if let Some(ctype) = ctype {
+    fn set_connection_type(&mut self, conn_type: Option<ConnectionType>) {
+        if let Some(ctype) = conn_type {
             self.head_mut().set_connection_type(ctype);
         }
     }
@@ -186,10 +208,17 @@ impl MessageType for Request {
         let mut headers: [HeaderIndex; MAX_HEADERS] = EMPTY_HEADER_INDEX_ARRAY;
 
         let (len, method, uri, ver, h_len) = {
-            let mut parsed: [httparse::Header<'_>; MAX_HEADERS] = EMPTY_HEADER_ARRAY;
+            // SAFETY:
+            // Create an uninitialized array of `MaybeUninit`. The `assume_init` is
+            // safe because the type we are claiming to have initialized here is a
+            // bunch of `MaybeUninit`s, which do not require initialization.
+            let mut parsed = unsafe {
+                MaybeUninit::<[MaybeUninit<httparse::Header<'_>>; MAX_HEADERS]>::uninit()
+                    .assume_init()
+            };
 
-            let mut req = httparse::Request::new(&mut parsed);
-            match req.parse(src)? {
+            let mut req = httparse::Request::new(&mut []);
+            match req.parse_with_uninit_headers(src, &mut parsed)? {
                 httparse::Status::Complete(len) => {
                     let method = Method::from_bytes(req.method.unwrap().as_bytes())
                         .map_err(|_| ParseError::Method)?;
@@ -246,8 +275,8 @@ impl MessageType for Request {
 }
 
 impl MessageType for ResponseHead {
-    fn set_connection_type(&mut self, ctype: Option<ConnectionType>) {
-        if let Some(ctype) = ctype {
+    fn set_connection_type(&mut self, conn_type: Option<ConnectionType>) {
+        if let Some(ctype) = conn_type {
             ResponseHead::set_connection_type(self, ctype);
         }
     }
@@ -408,20 +437,6 @@ enum Kind {
     Eof,
 }
 
-#[derive(Debug, PartialEq, Clone)]
-enum ChunkedState {
-    Size,
-    SizeLws,
-    Extension,
-    SizeLf,
-    Body,
-    BodyCr,
-    BodyLf,
-    EndCr,
-    EndLf,
-    End,
-}
-
 impl Decoder for PayloadDecoder {
     type Item = PayloadItem;
     type Error = io::Error;
@@ -451,19 +466,23 @@ impl Decoder for PayloadDecoder {
             Kind::Chunked(ref mut state, ref mut size) => {
                 loop {
                     let mut buf = None;
+
                     // advances the chunked state
                     *state = match state.step(src, size, &mut buf) {
                         Poll::Pending => return Ok(None),
                         Poll::Ready(Ok(state)) => state,
                         Poll::Ready(Err(e)) => return Err(e),
                     };
+
                     if *state == ChunkedState::End {
                         trace!("End of chunked stream");
                         return Ok(Some(PayloadItem::Eof));
                     }
+
                     if let Some(buf) = buf {
                         return Ok(Some(PayloadItem::Chunk(buf)));
                     }
+
                     if src.is_empty() {
                         return Ok(None);
                     }
@@ -480,201 +499,40 @@ impl Decoder for PayloadDecoder {
     }
 }
 
-macro_rules! byte (
-    ($rdr:ident) => ({
-        if $rdr.len() > 0 {
-            let b = $rdr[0];
-            $rdr.advance(1);
-            b
-        } else {
-            return Poll::Pending
-        }
-    })
-);
-
-impl ChunkedState {
-    fn step(
-        &self,
-        body: &mut BytesMut,
-        size: &mut u64,
-        buf: &mut Option<Bytes>,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
-        use self::ChunkedState::*;
-        match *self {
-            Size => ChunkedState::read_size(body, size),
-            SizeLws => ChunkedState::read_size_lws(body),
-            Extension => ChunkedState::read_extension(body),
-            SizeLf => ChunkedState::read_size_lf(body, size),
-            Body => ChunkedState::read_body(body, size, buf),
-            BodyCr => ChunkedState::read_body_cr(body),
-            BodyLf => ChunkedState::read_body_lf(body),
-            EndCr => ChunkedState::read_end_cr(body),
-            EndLf => ChunkedState::read_end_lf(body),
-            End => Poll::Ready(Ok(ChunkedState::End)),
-        }
-    }
-
-    fn read_size(
-        rdr: &mut BytesMut,
-        size: &mut u64,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
-        let radix = 16;
-        match byte!(rdr) {
-            b @ b'0'..=b'9' => {
-                *size *= radix;
-                *size += u64::from(b - b'0');
-            }
-            b @ b'a'..=b'f' => {
-                *size *= radix;
-                *size += u64::from(b + 10 - b'a');
-            }
-            b @ b'A'..=b'F' => {
-                *size *= radix;
-                *size += u64::from(b + 10 - b'A');
-            }
-            b'\t' | b' ' => return Poll::Ready(Ok(ChunkedState::SizeLws)),
-            b';' => return Poll::Ready(Ok(ChunkedState::Extension)),
-            b'\r' => return Poll::Ready(Ok(ChunkedState::SizeLf)),
-            _ => {
-                return Poll::Ready(Err(io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    "Invalid chunk size line: Invalid Size",
-                )));
-            }
-        }
-        Poll::Ready(Ok(ChunkedState::Size))
-    }
-
-    fn read_size_lws(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        trace!("read_size_lws");
-        match byte!(rdr) {
-            // LWS can follow the chunk size, but no more digits can come
-            b'\t' | b' ' => Poll::Ready(Ok(ChunkedState::SizeLws)),
-            b';' => Poll::Ready(Ok(ChunkedState::Extension)),
-            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk size linear white space",
-            ))),
-        }
-    }
-    fn read_extension(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
-            _ => Poll::Ready(Ok(ChunkedState::Extension)), // no supported extensions
-        }
-    }
-    fn read_size_lf(
-        rdr: &mut BytesMut,
-        size: &mut u64,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\n' if *size > 0 => Poll::Ready(Ok(ChunkedState::Body)),
-            b'\n' if *size == 0 => Poll::Ready(Ok(ChunkedState::EndCr)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk size LF",
-            ))),
-        }
-    }
-
-    fn read_body(
-        rdr: &mut BytesMut,
-        rem: &mut u64,
-        buf: &mut Option<Bytes>,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
-        trace!("Chunked read, remaining={:?}", rem);
-
-        let len = rdr.len() as u64;
-        if len == 0 {
-            Poll::Ready(Ok(ChunkedState::Body))
-        } else {
-            let slice;
-            if *rem > len {
-                slice = rdr.split().freeze();
-                *rem -= len;
-            } else {
-                slice = rdr.split_to(*rem as usize).freeze();
-                *rem = 0;
-            }
-            *buf = Some(slice);
-            if *rem > 0 {
-                Poll::Ready(Ok(ChunkedState::Body))
-            } else {
-                Poll::Ready(Ok(ChunkedState::BodyCr))
-            }
-        }
-    }
-
-    fn read_body_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::BodyLf)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk body CR",
-            ))),
-        }
-    }
-    fn read_body_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\n' => Poll::Ready(Ok(ChunkedState::Size)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk body LF",
-            ))),
-        }
-    }
-    fn read_end_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::EndLf)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk end CR",
-            ))),
-        }
-    }
-    fn read_end_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\n' => Poll::Ready(Ok(ChunkedState::End)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk end LF",
-            ))),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use bytes::{Bytes, BytesMut};
     use http::{Method, Version};
 
     use super::*;
-    use crate::error::ParseError;
-    use crate::http::header::{HeaderName, SET_COOKIE};
-    use crate::HttpMessage;
+    use crate::{
+        error::ParseError,
+        header::{HeaderName, SET_COOKIE},
+        HttpMessage as _,
+    };
 
     impl PayloadType {
-        fn unwrap(self) -> PayloadDecoder {
+        pub(crate) fn unwrap(self) -> PayloadDecoder {
             match self {
                 PayloadType::Payload(pl) => pl,
                 _ => panic!(),
             }
         }
 
-        fn is_unhandled(&self) -> bool {
+        pub(crate) fn is_unhandled(&self) -> bool {
             matches!(self, PayloadType::Stream(_))
         }
     }
 
     impl PayloadItem {
-        fn chunk(self) -> Bytes {
+        pub(crate) fn chunk(self) -> Bytes {
             match self {
                 PayloadItem::Chunk(chunk) => chunk,
                 _ => panic!("error"),
             }
         }
-        fn eof(&self) -> bool {
+
+        pub(crate) fn eof(&self) -> bool {
             matches!(*self, PayloadItem::Eof)
         }
     }
@@ -743,8 +601,7 @@ mod tests {
 
     #[test]
     fn test_parse_body() {
-        let mut buf =
-            BytesMut::from("GET /test HTTP/1.1\r\nContent-Length: 4\r\n\r\nbody");
+        let mut buf = BytesMut::from("GET /test HTTP/1.1\r\nContent-Length: 4\r\n\r\nbody");
 
         let mut reader = MessageDecoder::<Request>::default();
         let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
@@ -760,8 +617,7 @@ mod tests {
 
     #[test]
     fn test_parse_body_crlf() {
-        let mut buf =
-            BytesMut::from("\r\nGET /test HTTP/1.1\r\nContent-Length: 4\r\n\r\nbody");
+        let mut buf = BytesMut::from("\r\nGET /test HTTP/1.1\r\nContent-Length: 4\r\n\r\nbody");
 
         let mut reader = MessageDecoder::<Request>::default();
         let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
@@ -967,34 +823,6 @@ mod tests {
         assert!(req.upgrade());
     }
 
-    #[test]
-    fn test_request_chunked() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-        let req = parse_ready!(&mut buf);
-
-        if let Ok(val) = req.chunked() {
-            assert!(val);
-        } else {
-            unreachable!("Error");
-        }
-
-        // intentional typo in "chunked"
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chnked\r\n\r\n",
-        );
-        let req = parse_ready!(&mut buf);
-
-        if let Ok(val) = req.chunked() {
-            assert!(!val);
-        } else {
-            unreachable!("Error");
-        }
-    }
-
     #[test]
     fn test_headers_content_length_err_1() {
         let mut buf = BytesMut::from(
@@ -1112,126 +940,6 @@ mod tests {
         expect_parse_err!(&mut buf);
     }
 
-    #[test]
-    fn test_http_request_chunked_payload() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-        let mut reader = MessageDecoder::<Request>::default();
-        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-        assert!(req.chunked().unwrap());
-
-        buf.extend(b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n");
-        assert_eq!(
-            pl.decode(&mut buf).unwrap().unwrap().chunk().as_ref(),
-            b"data"
-        );
-        assert_eq!(
-            pl.decode(&mut buf).unwrap().unwrap().chunk().as_ref(),
-            b"line"
-        );
-        assert!(pl.decode(&mut buf).unwrap().unwrap().eof());
-    }
-
-    #[test]
-    fn test_http_request_chunked_payload_and_next_message() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-        let mut reader = MessageDecoder::<Request>::default();
-        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-        assert!(req.chunked().unwrap());
-
-        buf.extend(
-            b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n\
-              POST /test2 HTTP/1.1\r\n\
-              transfer-encoding: chunked\r\n\r\n"
-                .iter(),
-        );
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"data");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"line");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert!(msg.eof());
-
-        let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
-        assert!(req.chunked().unwrap());
-        assert_eq!(*req.method(), Method::POST);
-        assert!(req.chunked().unwrap());
-    }
-
-    #[test]
-    fn test_http_request_chunked_payload_chunks() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-
-        let mut reader = MessageDecoder::<Request>::default();
-        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-        assert!(req.chunked().unwrap());
-
-        buf.extend(b"4\r\n1111\r\n");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"1111");
-
-        buf.extend(b"4\r\ndata\r");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"data");
-
-        buf.extend(b"\n4");
-        assert!(pl.decode(&mut buf).unwrap().is_none());
-
-        buf.extend(b"\r");
-        assert!(pl.decode(&mut buf).unwrap().is_none());
-        buf.extend(b"\n");
-        assert!(pl.decode(&mut buf).unwrap().is_none());
-
-        buf.extend(b"li");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"li");
-
-        //trailers
-        //buf.feed_data("test: test\r\n");
-        //not_ready!(reader.parse(&mut buf, &mut readbuf));
-
-        buf.extend(b"ne\r\n0\r\n");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"ne");
-        assert!(pl.decode(&mut buf).unwrap().is_none());
-
-        buf.extend(b"\r\n");
-        assert!(pl.decode(&mut buf).unwrap().unwrap().eof());
-    }
-
-    #[test]
-    fn test_parse_chunked_payload_chunk_extension() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-            transfer-encoding: chunked\r\n\
-            \r\n",
-        );
-
-        let mut reader = MessageDecoder::<Request>::default();
-        let (msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-        assert!(msg.chunked().unwrap());
-
-        buf.extend(b"4;test\r\ndata\r\n4\r\nline\r\n0\r\n\r\n"); // test: test\r\n\r\n")
-        let chunk = pl.decode(&mut buf).unwrap().unwrap().chunk();
-        assert_eq!(chunk, Bytes::from_static(b"data"));
-        let chunk = pl.decode(&mut buf).unwrap().unwrap().chunk();
-        assert_eq!(chunk, Bytes::from_static(b"line"));
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert!(msg.eof());
-    }
-
     #[test]
     fn test_response_http10_read_until_eof() {
         let mut buf = BytesMut::from("HTTP/1.0 200 Ok\r\n\r\ntest data");
@@ -1243,4 +951,84 @@ mod tests {
         let chunk = pl.decode(&mut buf).unwrap().unwrap();
         assert_eq!(chunk, PayloadItem::Chunk(Bytes::from_static(b"test data")));
     }
+
+    #[test]
+    fn hrs_multiple_content_length() {
+        let mut buf = BytesMut::from(
+            "GET / HTTP/1.1\r\n\
+            Host: example.com\r\n\
+            Content-Length: 4\r\n\
+            Content-Length: 2\r\n\
+            \r\n\
+            abcd",
+        );
+
+        expect_parse_err!(&mut buf);
+    }
+
+    #[test]
+    fn hrs_content_length_plus() {
+        let mut buf = BytesMut::from(
+            "GET / HTTP/1.1\r\n\
+            Host: example.com\r\n\
+            Content-Length: +3\r\n\
+            \r\n\
+            000",
+        );
+
+        expect_parse_err!(&mut buf);
+    }
+
+    #[test]
+    fn hrs_unknown_transfer_encoding() {
+        let mut buf = BytesMut::from(
+            "GET / HTTP/1.1\r\n\
+            Host: example.com\r\n\
+            Transfer-Encoding: JUNK\r\n\
+            Transfer-Encoding: chunked\r\n\
+            \r\n\
+            5\r\n\
+            hello\r\n\
+            0",
+        );
+
+        expect_parse_err!(&mut buf);
+    }
+
+    #[test]
+    fn hrs_multiple_transfer_encoding() {
+        let mut buf = BytesMut::from(
+            "GET / HTTP/1.1\r\n\
+            Host: example.com\r\n\
+            Content-Length: 51\r\n\
+            Transfer-Encoding: identity\r\n\
+            Transfer-Encoding: chunked\r\n\
+            \r\n\
+            0\r\n\
+            \r\n\
+            GET /forbidden HTTP/1.1\r\n\
+            Host: example.com\r\n\r\n",
+        );
+
+        expect_parse_err!(&mut buf);
+    }
+
+    #[test]
+    fn transfer_encoding_agrees() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+            Host: example.com\r\n\
+            Content-Length: 3\r\n\
+            Transfer-Encoding: identity\r\n\
+            \r\n\
+            0\r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+
+        let chunk = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(chunk, PayloadItem::Chunk(Bytes::from_static(b"0\r\n")));
+    }
 }

actix-http/src/h1/encoder.rs

@@ -1,25 +1,26 @@
-use std::io::Write;
-use std::marker::PhantomData;
-use std::ptr::copy_nonoverlapping;
-use std::slice::from_raw_parts_mut;
-use std::{cmp, io};
+use std::{
+    cmp,
+    io::{self, Write as _},
+    marker::PhantomData,
+    ptr::copy_nonoverlapping,
+    slice::from_raw_parts_mut,
+};
 
 use bytes::{BufMut, BytesMut};
 
 use crate::{
     body::BodySize,
-    config::ServiceConfig,
-    header::{map::Value, HeaderMap, HeaderName},
-    header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING},
-    helpers,
-    message::{ConnectionType, RequestHeadType},
-    Response, StatusCode, Version,
+    header::{
+        map::Value, HeaderMap, HeaderName, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING,
+    },
+    helpers, ConnectionType, RequestHeadType, Response, ServiceConfig, StatusCode, Version,
 };
 
 const AVERAGE_HEADER_SIZE: usize = 30;
 
 #[derive(Debug)]
 pub(crate) struct MessageEncoder<T: MessageType> {
+    #[allow(dead_code)]
     pub length: BodySize,
     pub te: TransferEncoding,
     _phantom: PhantomData<T>,
@@ -55,7 +56,7 @@ pub(crate) trait MessageType: Sized {
         dst: &mut BytesMut,
         version: Version,
         mut length: BodySize,
-        ctype: ConnectionType,
+        conn_type: ConnectionType,
         config: &ServiceConfig,
     ) -> io::Result<()> {
         let chunked = self.chunked();
@@ -70,17 +71,28 @@ pub(crate) trait MessageType: Sized {
                 | StatusCode::PROCESSING
                 | StatusCode::NO_CONTENT => {
                     // skip content-length and transfer-encoding headers
-                    // See https://tools.ietf.org/html/rfc7230#section-3.3.1
-                    // and https://tools.ietf.org/html/rfc7230#section-3.3.2
+                    // see https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.1
+                    // and https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.2
                     skip_len = true;
                     length = BodySize::None
                 }
+
+                StatusCode::NOT_MODIFIED => {
+                    // 304 responses should never have a body but should retain a manually set
+                    // content-length header
+                    // see https://datatracker.ietf.org/doc/html/rfc7232#section-4.1
+                    skip_len = false;
+                    length = BodySize::None;
+                }
+
                 _ => {}
             }
         }
+
         match length {
             BodySize::Stream => {
                 if chunked {
+                    skip_len = true;
                     if camel_case {
                         dst.put_slice(b"\r\nTransfer-Encoding: chunked\r\n")
                     } else {
@@ -91,19 +103,14 @@ pub(crate) trait MessageType: Sized {
                     dst.put_slice(b"\r\n");
                 }
             }
-            BodySize::Empty => {
-                if camel_case {
-                    dst.put_slice(b"\r\nContent-Length: 0\r\n");
-                } else {
-                    dst.put_slice(b"\r\ncontent-length: 0\r\n");
-                }
-            }
+            BodySize::Sized(0) if camel_case => dst.put_slice(b"\r\nContent-Length: 0\r\n"),
+            BodySize::Sized(0) => dst.put_slice(b"\r\ncontent-length: 0\r\n"),
             BodySize::Sized(len) => helpers::write_content_length(len, dst),
             BodySize::None => dst.put_slice(b"\r\n"),
         }
 
         // Connection
-        match ctype {
+        match conn_type {
             ConnectionType::Upgrade => dst.put_slice(b"connection: upgrade\r\n"),
             ConnectionType::KeepAlive if version < Version::HTTP_11 => {
                 if camel_case {
@@ -174,7 +181,7 @@ pub(crate) trait MessageType: Sized {
                 unsafe {
                     if camel_case {
                         // use Camel-Case headers
-                        write_camel_case(k, from_raw_parts_mut(buf, k_len));
+                        write_camel_case(k, buf, k_len);
                     } else {
                         write_data(k, buf, k_len);
                     }
@@ -298,11 +305,7 @@ impl MessageType for RequestHeadType {
                 Version::HTTP_11 => "HTTP/1.1",
                 Version::HTTP_2 => "HTTP/2.0",
                 Version::HTTP_3 => "HTTP/3.0",
-                _ =>
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "unsupported version"
-                    )),
+                _ => return Err(io::Error::new(io::ErrorKind::Other, "unsupported version")),
             }
         )
         .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
@@ -328,13 +331,13 @@ impl<T: MessageType> MessageEncoder<T> {
         stream: bool,
         version: Version,
         length: BodySize,
-        ctype: ConnectionType,
+        conn_type: ConnectionType,
         config: &ServiceConfig,
     ) -> io::Result<()> {
         // transfer encoding
         if !head {
             self.te = match length {
-                BodySize::Empty => TransferEncoding::empty(),
+                BodySize::Sized(0) => TransferEncoding::empty(),
                 BodySize::Sized(len) => TransferEncoding::length(len),
                 BodySize::Stream => {
                     if message.chunked() && !stream {
@@ -350,7 +353,7 @@ impl<T: MessageType> MessageEncoder<T> {
         }
 
         message.encode_status(dst)?;
-        message.encode_headers(dst, version, length, ctype, config)
+        message.encode_headers(dst, version, length, conn_type, config)
     }
 }
 
@@ -364,10 +367,12 @@ pub(crate) struct TransferEncoding {
 enum TransferEncodingKind {
     /// An Encoder for when Transfer-Encoding includes `chunked`.
     Chunked(bool),
+
     /// An Encoder for when Content-Length is set.
     ///
     /// Enforces that the body is not longer than the Content-Length header.
     Length(u64),
+
     /// An Encoder for when Content-Length is not known.
     ///
     /// Application decides when to stop writing.
@@ -472,15 +477,22 @@ impl TransferEncoding {
 }
 
 /// # Safety
-/// Callers must ensure that the given length matches given value length.
+/// Callers must ensure that the given `len` matches the given `value` length and that `buf` is
+/// valid for writes of at least `len` bytes.
 unsafe fn write_data(value: &[u8], buf: *mut u8, len: usize) {
     debug_assert_eq!(value.len(), len);
     copy_nonoverlapping(value.as_ptr(), buf, len);
 }
 
-fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
+/// # Safety
+/// Callers must ensure that the given `len` matches the given `value` length and that `buf` is
+/// valid for writes of at least `len` bytes.
+unsafe fn write_camel_case(value: &[u8], buf: *mut u8, len: usize) {
     // first copy entire (potentially wrong) slice to output
-    buffer[..value.len()].copy_from_slice(value);
+    write_data(value, buf, len);
+
+    // SAFETY: We just initialized the buffer with `value`
+    let buffer = from_raw_parts_mut(buf, len);
 
     let mut iter = value.iter();
 
@@ -513,8 +525,10 @@ mod tests {
     use http::header::AUTHORIZATION;
 
     use super::*;
-    use crate::http::header::{HeaderValue, CONTENT_TYPE};
-    use crate::RequestHead;
+    use crate::{
+        header::{HeaderValue, CONTENT_TYPE},
+        RequestHead,
+    };
 
     #[test]
     fn test_chunked_te() {
@@ -544,12 +558,11 @@ mod tests {
         let _ = head.encode_headers(
             &mut bytes,
             Version::HTTP_11,
-            BodySize::Empty,
+            BodySize::Sized(0),
             ConnectionType::Close,
             &ServiceConfig::default(),
         );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        let data = String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
 
         assert!(data.contains("Content-Length: 0\r\n"));
         assert!(data.contains("Connection: close\r\n"));
@@ -563,8 +576,7 @@ mod tests {
             ConnectionType::KeepAlive,
             &ServiceConfig::default(),
         );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        let data = String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
         assert!(data.contains("Transfer-Encoding: chunked\r\n"));
         assert!(data.contains("Content-Type: plain/text\r\n"));
         assert!(data.contains("Date: date\r\n"));
@@ -585,8 +597,7 @@ mod tests {
             ConnectionType::KeepAlive,
             &ServiceConfig::default(),
         );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        let data = String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
         assert!(data.contains("transfer-encoding: chunked\r\n"));
         assert!(data.contains("content-type: xml\r\n"));
         assert!(data.contains("content-type: plain/text\r\n"));
@@ -615,12 +626,11 @@ mod tests {
         let _ = head.encode_headers(
             &mut bytes,
             Version::HTTP_11,
-            BodySize::Empty,
+            BodySize::Sized(0),
             ConnectionType::Close,
             &ServiceConfig::default(),
         );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        let data = String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
         assert!(data.contains("content-length: 0\r\n"));
         assert!(data.contains("connection: close\r\n"));
         assert!(data.contains("authorization: another authorization\r\n"));
@@ -643,8 +653,7 @@ mod tests {
             ConnectionType::Upgrade,
             &ServiceConfig::default(),
         );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        let data = String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
         assert!(!data.contains("content-length: 0\r\n"));
         assert!(!data.contains("transfer-encoding: chunked\r\n"));
     }

actix-http/src/h1/expect.rs

@@ -1,8 +1,7 @@
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ready, Ready};
 
-use crate::error::Error;
-use crate::request::Request;
+use crate::{Error, Request};
 
 pub struct ExpectHandler;
 

actix-http/src/h1/mod.rs

@@ -1,6 +1,8 @@
 //! HTTP/1 protocol implementation.
+
 use bytes::{Bytes, BytesMut};
 
+mod chunked;
 mod client;
 mod codec;
 mod decoder;
@@ -57,7 +59,7 @@ pub(crate) fn reserve_readbuf(src: &mut BytesMut) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::request::Request;
+    use crate::Request;
 
     impl Message<Request> {
         pub fn message(self) -> Request {

actix-http/src/h1/payload.rs

@@ -1,9 +1,12 @@
 //! Payload stream
-use std::cell::RefCell;
-use std::collections::VecDeque;
-use std::pin::Pin;
-use std::rc::{Rc, Weak};
-use std::task::{Context, Poll, Waker};
+
+use std::{
+    cell::RefCell,
+    collections::VecDeque,
+    pin::Pin,
+    rc::{Rc, Weak},
+    task::{Context, Poll, Waker},
+};
 
 use bytes::Bytes;
 use futures_core::Stream;
@@ -22,39 +25,32 @@ pub enum PayloadStatus {
 
 /// Buffered stream of bytes chunks
 ///
-/// Payload stores chunks in a vector. First chunk can be received with
-/// `.readany()` method. Payload stream is not thread safe. Payload does not
-/// notify current task when new data is available.
+/// Payload stores chunks in a vector. First chunk can be received with `poll_next`. Payload does
+/// not notify current task when new data is available.
 ///
-/// Payload stream can be used as `Response` body stream.
+/// Payload can be used as `Response` body stream.
 #[derive(Debug)]
 pub struct Payload {
     inner: Rc<RefCell<Inner>>,
 }
 
 impl Payload {
-    /// Create payload stream.
+    /// Creates a payload stream.
     ///
-    /// This method construct two objects responsible for bytes stream
-    /// generation.
-    ///
-    /// * `PayloadSender` - *Sender* side of the stream
-    ///
-    /// * `Payload` - *Receiver* side of the stream
+    /// This method construct two objects responsible for bytes stream generation:
+    /// - `PayloadSender` - *Sender* side of the stream
+    /// - `Payload` - *Receiver* side of the stream
     pub fn create(eof: bool) -> (PayloadSender, Payload) {
         let shared = Rc::new(RefCell::new(Inner::new(eof)));
 
         (
-            PayloadSender {
-                inner: Rc::downgrade(&shared),
-            },
+            PayloadSender::new(Rc::downgrade(&shared)),
             Payload { inner: shared },
         )
     }
 
-    /// Create empty payload
-    #[doc(hidden)]
-    pub fn empty() -> Payload {
+    /// Creates an empty payload.
+    pub(crate) fn empty() -> Payload {
         Payload {
             inner: Rc::new(RefCell::new(Inner::new(true))),
         }
@@ -77,14 +73,6 @@ impl Payload {
     pub fn unread_data(&mut self, data: Bytes) {
         self.inner.borrow_mut().unread_data(data);
     }
-
-    #[inline]
-    pub fn readany(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
-    }
 }
 
 impl Stream for Payload {
@@ -94,7 +82,7 @@ impl Stream for Payload {
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
+        Pin::new(&mut *self.inner.borrow_mut()).poll_next(cx)
     }
 }
 
@@ -104,6 +92,10 @@ pub struct PayloadSender {
 }
 
 impl PayloadSender {
+    fn new(inner: Weak<RefCell<Inner>>) -> Self {
+        Self { inner }
+    }
+
     #[inline]
     pub fn set_error(&mut self, err: PayloadError) {
         if let Some(shared) = self.inner.upgrade() {
@@ -186,8 +178,7 @@ impl Inner {
         if self
             .task
             .as_ref()
-            .map(|w| !cx.waker().will_wake(w))
-            .unwrap_or(true)
+            .map_or(true, |w| !cx.waker().will_wake(w))
         {
             self.task = Some(cx.waker().clone());
         }
@@ -199,8 +190,7 @@ impl Inner {
         if self
             .io_task
             .as_ref()
-            .map(|w| !cx.waker().will_wake(w))
-            .unwrap_or(true)
+            .map_or(true, |w| !cx.waker().will_wake(w))
         {
             self.io_task = Some(cx.waker().clone());
         }
@@ -229,8 +219,8 @@ impl Inner {
         self.len
     }
 
-    fn readany(
-        &mut self,
+    fn poll_next(
+        mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, PayloadError>>> {
         if let Some(data) = self.items.pop_front() {
@@ -262,8 +252,18 @@ impl Inner {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
     use actix_utils::future::poll_fn;
+    use static_assertions::{assert_impl_all, assert_not_impl_any};
+
+    use super::*;
+
+    assert_impl_all!(Payload: Unpin);
+    assert_not_impl_any!(Payload: Send, Sync, UnwindSafe, RefUnwindSafe);
+
+    assert_impl_all!(Inner: Unpin, Send, Sync);
+    assert_not_impl_any!(Inner: UnwindSafe, RefUnwindSafe);
 
     #[actix_rt::test]
     async fn test_unread_data() {
@@ -275,7 +275,10 @@ mod tests {
 
         assert_eq!(
             Bytes::from("data"),
-            poll_fn(|cx| payload.readany(cx)).await.unwrap().unwrap()
+            poll_fn(|cx| Pin::new(&mut payload).poll_next(cx))
+                .await
+                .unwrap()
+                .unwrap()
         );
     }
 }

actix-http/src/h1/service.rs

@@ -1,5 +1,4 @@
 use std::{
-    error::Error as StdError,
     fmt,
     marker::PhantomData,
     net,
@@ -16,7 +15,7 @@ use actix_utils::future::ready;
 use futures_core::future::LocalBoxFuture;
 
 use crate::{
-    body::{AnyBody, MessageBody},
+    body::{BoxBody, MessageBody},
     config::ServiceConfig,
     error::DispatchError,
     service::HttpServiceHandler,
@@ -38,7 +37,7 @@ pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
 impl<T, S, B> H1Service<T, S, B>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>>,
+    S::Error: Into<Response<BoxBody>>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
     B: MessageBody,
@@ -63,21 +62,20 @@ impl<S, B, X, U> H1Service<TcpStream, S, B, X, U>
 where
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Response<AnyBody>>,
+    S::Error: Into<Response<BoxBody>>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
 
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
 
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
-    X::Error: Into<Response<AnyBody>>,
+    X::Error: Into<Response<BoxBody>>,
     X::InitError: fmt::Debug,
 
     U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
     U::Future: 'static,
-    U::Error: fmt::Display + Into<Response<AnyBody>>,
+    U::Error: fmt::Display + Into<Response<BoxBody>>,
     U::InitError: fmt::Debug,
 {
     /// Create simple tcp stream service
@@ -102,9 +100,11 @@ where
 mod openssl {
     use super::*;
 
-    use actix_service::ServiceFactoryExt;
     use actix_tls::accept::{
-        openssl::{Acceptor, SslAcceptor, SslError, TlsStream},
+        openssl::{
+            reexports::{Error as SslError, SslAcceptor},
+            Acceptor, TlsStream,
+        },
         TlsError,
     };
 
@@ -112,16 +112,15 @@ mod openssl {
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Response<AnyBody>>,
+        S::Error: Into<Response<BoxBody>>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
 
         B: MessageBody,
-        B::Error: Into<Box<dyn StdError>>,
 
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
-        X::Error: Into<Response<AnyBody>>,
+        X::Error: Into<Response<BoxBody>>,
         X::InitError: fmt::Debug,
 
         U: ServiceFactory<
@@ -130,10 +129,10 @@ mod openssl {
             Response = (),
         >,
         U::Future: 'static,
-        U::Error: fmt::Display + Into<Response<AnyBody>>,
+        U::Error: fmt::Display + Into<Response<BoxBody>>,
         U::InitError: fmt::Debug,
     {
-        /// Create openssl based service
+        /// Create OpenSSL based service.
         pub fn openssl(
             self,
             acceptor: SslAcceptor,
@@ -145,11 +144,13 @@ mod openssl {
             InitError = (),
         > {
             Acceptor::new(acceptor)
-                .map_err(TlsError::Tls)
-                .map_init_err(|_| panic!())
-                .and_then(|io: TlsStream<TcpStream>| {
+                .map_init_err(|_| {
+                    unreachable!("TLS acceptor service factory does not error on init")
+                })
+                .map_err(TlsError::into_service_error)
+                .map(|io: TlsStream<TcpStream>| {
                     let peer_addr = io.get_ref().peer_addr().ok();
-                    ready(Ok((io, peer_addr)))
+                    (io, peer_addr)
                 })
                 .and_then(self.map_err(TlsError::Service))
         }
@@ -158,30 +159,30 @@ mod openssl {
 
 #[cfg(feature = "rustls")]
 mod rustls {
-    use super::*;
 
     use std::io;
 
-    use actix_service::ServiceFactoryExt;
+    use actix_service::ServiceFactoryExt as _;
     use actix_tls::accept::{
-        rustls::{Acceptor, ServerConfig, TlsStream},
+        rustls::{reexports::ServerConfig, Acceptor, TlsStream},
         TlsError,
     };
 
+    use super::*;
+
     impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Response<AnyBody>>,
+        S::Error: Into<Response<BoxBody>>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
 
         B: MessageBody,
-        B::Error: Into<Box<dyn StdError>>,
 
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
-        X::Error: Into<Response<AnyBody>>,
+        X::Error: Into<Response<BoxBody>>,
         X::InitError: fmt::Debug,
 
         U: ServiceFactory<
@@ -190,10 +191,10 @@ mod rustls {
             Response = (),
         >,
         U::Future: 'static,
-        U::Error: fmt::Display + Into<Response<AnyBody>>,
+        U::Error: fmt::Display + Into<Response<BoxBody>>,
         U::InitError: fmt::Debug,
     {
-        /// Create rustls based service
+        /// Create Rustls based service.
         pub fn rustls(
             self,
             config: ServerConfig,
@@ -205,11 +206,13 @@ mod rustls {
             InitError = (),
         > {
             Acceptor::new(config)
-                .map_err(TlsError::Tls)
-                .map_init_err(|_| panic!())
-                .and_then(|io: TlsStream<TcpStream>| {
+                .map_init_err(|_| {
+                    unreachable!("TLS acceptor service factory does not error on init")
+                })
+                .map_err(TlsError::into_service_error)
+                .map(|io: TlsStream<TcpStream>| {
                     let peer_addr = io.get_ref().0.peer_addr().ok();
-                    ready(Ok((io, peer_addr)))
+                    (io, peer_addr)
                 })
                 .and_then(self.map_err(TlsError::Service))
         }
@@ -219,7 +222,7 @@ mod rustls {
 impl<T, S, B, X, U> H1Service<T, S, B, X, U>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>>,
+    S::Error: Into<Response<BoxBody>>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
     B: MessageBody,
@@ -227,7 +230,7 @@ where
     pub fn expect<X1>(self, expect: X1) -> H1Service<T, S, B, X1, U>
     where
         X1: ServiceFactory<Request, Response = Request>,
-        X1::Error: Into<Response<AnyBody>>,
+        X1::Error: Into<Response<BoxBody>>,
         X1::InitError: fmt::Debug,
     {
         H1Service {
@@ -263,28 +266,26 @@ where
     }
 }
 
-impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)>
-    for H1Service<T, S, B, X, U>
+impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)> for H1Service<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
 
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Response<AnyBody>>,
+    S::Error: Into<Response<BoxBody>>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
 
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
 
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
-    X::Error: Into<Response<AnyBody>>,
+    X::Error: Into<Response<BoxBody>>,
     X::InitError: fmt::Debug,
 
     U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
     U::Future: 'static,
-    U::Error: fmt::Display + Into<Response<AnyBody>>,
+    U::Error: fmt::Display + Into<Response<BoxBody>>,
     U::InitError: fmt::Debug,
 {
     type Response = ();
@@ -308,9 +309,9 @@ where
 
             let upgrade = match upgrade {
                 Some(upgrade) => {
-                    let upgrade = upgrade.await.map_err(|e| {
-                        log::error!("Init http upgrade service error: {:?}", e)
-                    })?;
+                    let upgrade = upgrade
+                        .await
+                        .map_err(|e| log::error!("Init http upgrade service error: {:?}", e))?;
                     Some(upgrade)
                 }
                 None => None,
@@ -334,45 +335,35 @@ where
 /// `Service` implementation for HTTP/1 transport
 pub type H1ServiceHandler<T, S, B, X, U> = HttpServiceHandler<T, S, B, X, U>;
 
-impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)>
-    for HttpServiceHandler<T, S, B, X, U>
+impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)> for HttpServiceHandler<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
 
     S: Service<Request>,
-    S::Error: Into<Response<AnyBody>>,
+    S::Error: Into<Response<BoxBody>>,
     S::Response: Into<Response<B>>,
 
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
 
     X: Service<Request, Response = Request>,
-    X::Error: Into<Response<AnyBody>>,
+    X::Error: Into<Response<BoxBody>>,
 
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Response<AnyBody>>,
+    U::Error: fmt::Display + Into<Response<BoxBody>>,
 {
     type Response = ();
     type Error = DispatchError;
     type Future = Dispatcher<T, S, B, X, U>;
 
     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self._poll_ready(cx).map_err(|e| {
-            log::error!("HTTP/1 service readiness error: {:?}", e);
-            DispatchError::Service(e)
+        self._poll_ready(cx).map_err(|err| {
+            log::error!("HTTP/1 service readiness error: {:?}", err);
+            DispatchError::Service(err)
         })
     }
 
     fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
-        let on_connect_data =
-            OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
-
-        Dispatcher::new(
-            io,
-            self.cfg.clone(),
-            self.flow.clone(),
-            on_connect_data,
-            addr,
-        )
+        let conn_data = OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
+        Dispatcher::new(io, self.flow.clone(), self.cfg.clone(), addr, conn_data)
     }
 }

actix-http/src/h1/upgrade.rs

@@ -2,9 +2,7 @@ use actix_codec::Framed;
 use actix_service::{Service, ServiceFactory};
 use futures_core::future::LocalBoxFuture;
 
-use crate::error::Error;
-use crate::h1::Codec;
-use crate::request::Request;
+use crate::{h1::Codec, Error, Request};
 
 pub struct UpgradeHandler;
 

actix-http/src/h1/utils.rs

@@ -1,22 +1,29 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use pin_project_lite::pin_project;
 
-use crate::body::{BodySize, MessageBody};
-use crate::error::Error;
-use crate::h1::{Codec, Message};
-use crate::response::Response;
+use crate::{
+    body::{BodySize, MessageBody},
+    h1::{Codec, Message},
+    Error, Response,
+};
 
-/// Send HTTP/1 response
-#[pin_project::pin_project]
-pub struct SendResponse<T, B> {
-    res: Option<Message<(Response<()>, BodySize)>>,
-    #[pin]
-    body: Option<B>,
-    #[pin]
-    framed: Option<Framed<T, Codec>>,
+pin_project! {
+    /// Send HTTP/1 response
+    pub struct SendResponse<T, B> {
+        res: Option<Message<(Response<()>, BodySize)>>,
+
+        #[pin]
+        body: Option<B>,
+
+        #[pin]
+        framed: Option<Framed<T, Codec>>,
+    }
 }
 
 impl<T, B> SendResponse<T, B>
@@ -38,7 +45,7 @@ where
 impl<T, B> Future for SendResponse<T, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    B: MessageBody + Unpin,
+    B: MessageBody,
     B::Error: Into<Error>,
 {
     type Output = Result<Framed<T, Codec>, Error>;
@@ -62,28 +69,24 @@ where
                         .unwrap()
                         .is_write_buf_full()
                 {
-                    let next =
-                        // TODO: MSRV 1.51: poll_map_err
-                        match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx) {
-                            Poll::Ready(Some(Ok(item))) => Poll::Ready(Some(item)),
-                            Poll::Ready(Some(Err(err))) => {
-                                return Poll::Ready(Err(err.into()))
-                            }
-                            Poll::Ready(None) => Poll::Ready(None),
-                            Poll::Pending => Poll::Pending,
-                        };
+                    let next = match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx) {
+                        Poll::Ready(Some(Ok(item))) => Poll::Ready(Some(item)),
+                        Poll::Ready(Some(Err(err))) => return Poll::Ready(Err(err.into())),
+                        Poll::Ready(None) => Poll::Ready(None),
+                        Poll::Pending => Poll::Pending,
+                    };
 
                     match next {
                         Poll::Ready(item) => {
                             // body is done when item is None
                             body_done = item.is_none();
                             if body_done {
-                                let _ = this.body.take();
+                                this.body.set(None);
                             }
                             let framed = this.framed.as_mut().as_pin_mut().unwrap();
-                            framed.write(Message::Chunk(item)).map_err(|err| {
-                                Error::new_send_response().with_cause(err)
-                            })?;
+                            framed
+                                .write(Message::Chunk(item))
+                                .map_err(|err| Error::new_send_response().with_cause(err))?;
                         }
                         Poll::Pending => body_ready = false,
                     }

actix-http/src/h2/dispatcher.rs

@@ -10,20 +10,24 @@ use std::{
 };
 
 use actix_codec::{AsyncRead, AsyncWrite};
+use actix_rt::time::{sleep, Sleep};
 use actix_service::Service;
 use actix_utils::future::poll_fn;
 use bytes::{Bytes, BytesMut};
 use futures_core::ready;
-use h2::server::{Connection, SendResponse};
-use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
+use h2::{
+    server::{Connection, SendResponse},
+    Ping, PingPong,
+};
 use log::{error, trace};
 use pin_project_lite::pin_project;
 
 use crate::{
-    body::{AnyBody, BodySize, MessageBody},
+    body::{BodySize, BoxBody, MessageBody},
     config::ServiceConfig,
+    header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING},
     service::HttpFlow,
-    OnConnectData, Payload, Request, Response, ResponseHead,
+    Extensions, OnConnectData, Payload, Request, Response, ResponseHead,
 };
 
 const CHUNK_SIZE: usize = 16_384;
@@ -33,43 +37,66 @@ pin_project! {
     pub struct Dispatcher<T, S, B, X, U> {
         flow: Rc<HttpFlow<S, X, U>>,
         connection: Connection<T, Bytes>,
-        on_connect_data: OnConnectData,
+        conn_data: Option<Rc<Extensions>>,
         config: ServiceConfig,
         peer_addr: Option<net::SocketAddr>,
-        _phantom: PhantomData<B>,
+        ping_pong: Option<H2PingPong>,
+        _phantom: PhantomData<B>
     }
 }
 
-impl<T, S, B, X, U> Dispatcher<T, S, B, X, U> {
+impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
     pub(crate) fn new(
+        mut conn: Connection<T, Bytes>,
         flow: Rc<HttpFlow<S, X, U>>,
-        connection: Connection<T, Bytes>,
-        on_connect_data: OnConnectData,
         config: ServiceConfig,
         peer_addr: Option<net::SocketAddr>,
+        conn_data: OnConnectData,
+        timer: Option<Pin<Box<Sleep>>>,
     ) -> Self {
+        let ping_pong = config.keep_alive().map(|dur| H2PingPong {
+            timer: timer
+                .map(|mut timer| {
+                    // reset timer if it's received from new function.
+                    timer.as_mut().reset(config.now() + dur);
+                    timer
+                })
+                .unwrap_or_else(|| Box::pin(sleep(dur))),
+            on_flight: false,
+            ping_pong: conn.ping_pong().unwrap(),
+        });
+
         Self {
             flow,
             config,
             peer_addr,
-            connection,
-            on_connect_data,
+            connection: conn,
+            conn_data: conn_data.0.map(Rc::new),
+            ping_pong,
             _phantom: PhantomData,
         }
     }
 }
 
+struct H2PingPong {
+    timer: Pin<Box<Sleep>>,
+    on_flight: bool,
+    ping_pong: PingPong,
+}
+
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
 
     S: Service<Request>,
-    S::Error: Into<Response<AnyBody>>,
+    S::Error: Into<Response<BoxBody>>,
     S::Future: 'static,
     S::Response: Into<Response<B>>,
 
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
 {
     type Output = Result<(), crate::error::DispatchError>;
 
@@ -77,54 +104,86 @@ where
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
 
-        while let Some((req, tx)) =
-            ready!(Pin::new(&mut this.connection).poll_accept(cx)?)
-        {
-            let (parts, body) = req.into_parts();
-            let pl = crate::h2::Payload::new(body);
-            let pl = Payload::<crate::payload::PayloadStream>::H2(pl);
-            let mut req = Request::with_payload(pl);
+        loop {
+            match Pin::new(&mut this.connection).poll_accept(cx)? {
+                Poll::Ready(Some((req, tx))) => {
+                    let (parts, body) = req.into_parts();
+                    let payload = crate::h2::Payload::new(body);
+                    let pl = Payload::H2 { payload };
+                    let mut req = Request::with_payload(pl);
 
-            let head = req.head_mut();
-            head.uri = parts.uri;
-            head.method = parts.method;
-            head.version = parts.version;
-            head.headers = parts.headers.into();
-            head.peer_addr = this.peer_addr;
+                    let head = req.head_mut();
+                    head.uri = parts.uri;
+                    head.method = parts.method;
+                    head.version = parts.version;
+                    head.headers = parts.headers.into();
+                    head.peer_addr = this.peer_addr;
 
-            // merge on_connect_ext data into request extensions
-            this.on_connect_data.merge_into(&mut req);
+                    req.conn_data = this.conn_data.as_ref().map(Rc::clone);
 
-            let fut = this.flow.service.call(req);
-            let config = this.config.clone();
+                    let fut = this.flow.service.call(req);
+                    let config = this.config.clone();
 
-            // multiplex request handling with spawn task
-            actix_rt::spawn(async move {
-                // resolve service call and send response.
-                let res = match fut.await {
-                    Ok(res) => handle_response(res.into(), tx, config).await,
-                    Err(err) => {
-                        let res: Response<AnyBody> = err.into();
-                        handle_response(res, tx, config).await
-                    }
-                };
+                    // multiplex request handling with spawn task
+                    actix_rt::spawn(async move {
+                        // resolve service call and send response.
+                        let res = match fut.await {
+                            Ok(res) => handle_response(res.into(), tx, config).await,
+                            Err(err) => {
+                                let res: Response<BoxBody> = err.into();
+                                handle_response(res, tx, config).await
+                            }
+                        };
 
-                // log error.
-                if let Err(err) = res {
-                    match err {
-                        DispatchError::SendResponse(err) => {
-                            trace!("Error sending HTTP/2 response: {:?}", err)
+                        // log error.
+                        if let Err(err) = res {
+                            match err {
+                                DispatchError::SendResponse(err) => {
+                                    trace!("Error sending HTTP/2 response: {:?}", err)
+                                }
+                                DispatchError::SendData(err) => warn!("{:?}", err),
+                                DispatchError::ResponseBody(err) => {
+                                    error!("Response payload stream error: {:?}", err)
+                                }
+                            }
                         }
-                        DispatchError::SendData(err) => warn!("{:?}", err),
-                        DispatchError::ResponseBody(err) => {
-                            error!("Response payload stream error: {:?}", err)
-                        }
-                    }
+                    });
                 }
-            });
-        }
+                Poll::Ready(None) => return Poll::Ready(Ok(())),
+                Poll::Pending => match this.ping_pong.as_mut() {
+                    Some(ping_pong) => loop {
+                        if ping_pong.on_flight {
+                            // When have on flight ping pong. poll pong and and keep alive timer.
+                            // on success pong received update keep alive timer to determine the next timing of
+                            // ping pong.
+                            match ping_pong.ping_pong.poll_pong(cx)? {
+                                Poll::Ready(_) => {
+                                    ping_pong.on_flight = false;
 
-        Poll::Ready(Ok(()))
+                                    let dead_line = this.config.keep_alive_expire().unwrap();
+                                    ping_pong.timer.as_mut().reset(dead_line);
+                                }
+                                Poll::Pending => {
+                                    return ping_pong.timer.as_mut().poll(cx).map(|_| Ok(()))
+                                }
+                            }
+                        } else {
+                            // When there is no on flight ping pong. keep alive timer is used to wait for next
+                            // timing of ping pong. Therefore at this point it serves as an interval instead.
+                            ready!(ping_pong.timer.as_mut().poll(cx));
+
+                            ping_pong.ping_pong.send_ping(Ping::opaque())?;
+
+                            let dead_line = this.config.keep_alive_expire().unwrap();
+                            ping_pong.timer.as_mut().reset(dead_line);
+
+                            ping_pong.on_flight = true;
+                        }
+                    },
+                    None => return Poll::Pending,
+                },
+            }
+        }
     }
 }
 
@@ -141,7 +200,6 @@ async fn handle_response<B>(
 ) -> Result<(), DispatchError>
 where
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
 {
     let (res, body) = res.replace_body(());
 
@@ -159,25 +217,28 @@ where
         return Ok(());
     }
 
-    // poll response body and send chunks to client.
+    // poll response body and send chunks to client
     actix_rt::pin!(body);
 
     while let Some(res) = poll_fn(|cx| body.as_mut().poll_next(cx)).await {
         let mut chunk = res.map_err(|err| DispatchError::ResponseBody(err.into()))?;
 
         'send: loop {
+            let chunk_size = cmp::min(chunk.len(), CHUNK_SIZE);
+
             // reserve enough space and wait for stream ready.
-            stream.reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
+            stream.reserve_capacity(chunk_size);
 
             match poll_fn(|cx| stream.poll_capacity(cx)).await {
                 // No capacity left. drop body and return.
                 None => return Ok(()),
-                Some(res) => {
-                    // Split chuck to writeable size and send to client.
-                    let cap = res.map_err(DispatchError::SendData)?;
 
+                Some(Err(err)) => return Err(DispatchError::SendData(err)),
+
+                Some(Ok(cap)) => {
+                    // split chunk to writeable size and send to client
                     let len = chunk.len();
-                    let bytes = chunk.split_to(cmp::min(cap, len));
+                    let bytes = chunk.split_to(cmp::min(len, cap));
 
                     stream
                         .send_data(bytes, false)
@@ -226,9 +287,13 @@ fn prepare_response(
 
     let _ = match size {
         BodySize::None | BodySize::Stream => None,
-        BodySize::Empty => res
-            .headers_mut()
-            .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
+
+        BodySize::Sized(0) => {
+            #[allow(clippy::declare_interior_mutable_const)]
+            const HV_ZERO: HeaderValue = HeaderValue::from_static("0");
+            res.headers_mut().insert(CONTENT_LENGTH, HV_ZERO)
+        }
+
         BodySize::Sized(len) => {
             let mut buf = itoa::Buffer::new();
 
@@ -243,7 +308,7 @@ fn prepare_response(
     for (key, value) in head.headers.iter() {
         match *key {
             // TODO: consider skipping other headers according to:
-            //       https://tools.ietf.org/html/rfc7540#section-8.1.2.2
+            //       https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2.2
             // omit HTTP/1.x only headers
             CONNECTION | TRANSFER_ENCODING => continue,
             CONTENT_LENGTH if skip_len => continue,

actix-http/src/h2/mod.rs

@@ -1,20 +1,30 @@
 //! HTTP/2 protocol.
 
 use std::{
+    future::Future,
     pin::Pin,
     task::{Context, Poll},
 };
 
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_rt::time::Sleep;
 use bytes::Bytes;
 use futures_core::{ready, Stream};
-use h2::RecvStream;
+use h2::{
+    server::{handshake, Connection, Handshake},
+    RecvStream,
+};
 
 mod dispatcher;
 mod service;
 
 pub use self::dispatcher::Dispatcher;
 pub use self::service::H2Service;
-use crate::error::PayloadError;
+
+use crate::{
+    config::ServiceConfig,
+    error::{DispatchError, PayloadError},
+};
 
 /// HTTP/2 peer stream.
 pub struct Payload {
@@ -30,10 +40,7 @@ impl Payload {
 impl Stream for Payload {
     type Item = Result<Bytes, PayloadError>;
 
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
 
         match ready!(Pin::new(&mut this.stream).poll_data(cx)) {
@@ -50,3 +57,55 @@ impl Stream for Payload {
         }
     }
 }
+
+pub(crate) fn handshake_with_timeout<T>(
+    io: T,
+    config: &ServiceConfig,
+) -> HandshakeWithTimeout<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    HandshakeWithTimeout {
+        handshake: handshake(io),
+        timer: config.client_timer().map(Box::pin),
+    }
+}
+
+pub(crate) struct HandshakeWithTimeout<T: AsyncRead + AsyncWrite + Unpin> {
+    handshake: Handshake<T>,
+    timer: Option<Pin<Box<Sleep>>>,
+}
+
+impl<T> Future for HandshakeWithTimeout<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    type Output = Result<(Connection<T, Bytes>, Option<Pin<Box<Sleep>>>), DispatchError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        match Pin::new(&mut this.handshake).poll(cx)? {
+            // return the timer on success handshake. It can be re-used for h2 ping-pong.
+            Poll::Ready(conn) => Poll::Ready(Ok((conn, this.timer.take()))),
+            Poll::Pending => match this.timer.as_mut() {
+                Some(timer) => {
+                    ready!(timer.as_mut().poll(cx));
+                    Poll::Ready(Err(DispatchError::SlowRequestTimeout))
+                }
+                None => Poll::Pending,
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
+    use static_assertions::assert_impl_all;
+
+    use super::*;
+
+    assert_impl_all!(Payload: Unpin, Send, Sync, UnwindSafe, RefUnwindSafe);
+}

actix-http/src/h2/service.rs

@@ -1,8 +1,7 @@
 use std::{
-    error::Error as StdError,
     future::Future,
     marker::PhantomData,
-    net,
+    mem, net,
     pin::Pin,
     rc::Rc,
     task::{Context, Poll},
@@ -11,24 +10,21 @@ use std::{
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
 use actix_service::{
-    fn_factory, fn_service, IntoServiceFactory, Service, ServiceFactory,
-    ServiceFactoryExt as _,
+    fn_factory, fn_service, IntoServiceFactory, Service, ServiceFactory, ServiceFactoryExt as _,
 };
 use actix_utils::future::ready;
-use bytes::Bytes;
 use futures_core::{future::LocalBoxFuture, ready};
-use h2::server::{handshake as h2_handshake, Handshake as H2Handshake};
 use log::error;
 
 use crate::{
-    body::{AnyBody, MessageBody},
+    body::{BoxBody, MessageBody},
     config::ServiceConfig,
     error::DispatchError,
     service::HttpFlow,
     ConnectCallback, OnConnectData, Request, Response,
 };
 
-use super::dispatcher::Dispatcher;
+use super::{dispatcher::Dispatcher, handshake_with_timeout, HandshakeWithTimeout};
 
 /// `ServiceFactory` implementation for HTTP/2 transport
 pub struct H2Service<T, S, B> {
@@ -41,12 +37,11 @@ pub struct H2Service<T, S, B> {
 impl<T, S, B> H2Service<T, S, B>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
 
     B: MessageBody + 'static,
-    B::Error: Into<Box<dyn StdError>>,
 {
     /// Create new `H2Service` instance with config.
     pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
@@ -72,12 +67,11 @@ impl<S, B> H2Service<TcpStream, S, B>
 where
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
 
     B: MessageBody + 'static,
-    B::Error: Into<Box<dyn StdError>>,
 {
     /// Create plain TCP based service
     pub fn tcp(
@@ -101,9 +95,14 @@ where
 
 #[cfg(feature = "openssl")]
 mod openssl {
-    use actix_service::{fn_factory, fn_service, ServiceFactoryExt};
-    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, TlsStream};
-    use actix_tls::accept::TlsError;
+    use actix_service::ServiceFactoryExt as _;
+    use actix_tls::accept::{
+        openssl::{
+            reexports::{Error as SslError, SslAcceptor},
+            Acceptor, TlsStream,
+        },
+        TlsError,
+    };
 
     use super::*;
 
@@ -111,14 +110,13 @@ mod openssl {
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Response<AnyBody>> + 'static,
+        S::Error: Into<Response<BoxBody>> + 'static,
         S::Response: Into<Response<B>> + 'static,
         <S::Service as Service<Request>>::Future: 'static,
 
         B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
     {
-        /// Create OpenSSL based service
+        /// Create OpenSSL based service.
         pub fn openssl(
             self,
             acceptor: SslAcceptor,
@@ -130,16 +128,14 @@ mod openssl {
             InitError = S::InitError,
         > {
             Acceptor::new(acceptor)
-                .map_err(TlsError::Tls)
-                .map_init_err(|_| panic!())
-                .and_then(fn_factory(|| {
-                    ready(Ok::<_, S::InitError>(fn_service(
-                        |io: TlsStream<TcpStream>| {
-                            let peer_addr = io.get_ref().peer_addr().ok();
-                            ready(Ok((io, peer_addr)))
-                        },
-                    )))
-                }))
+                .map_init_err(|_| {
+                    unreachable!("TLS acceptor service factory does not error on init")
+                })
+                .map_err(TlsError::into_service_error)
+                .map(|io: TlsStream<TcpStream>| {
+                    let peer_addr = io.get_ref().peer_addr().ok();
+                    (io, peer_addr)
+                })
                 .and_then(self.map_err(TlsError::Service))
         }
     }
@@ -147,24 +143,27 @@ mod openssl {
 
 #[cfg(feature = "rustls")]
 mod rustls {
-    use super::*;
-    use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::accept::TlsError;
     use std::io;
 
+    use actix_service::ServiceFactoryExt as _;
+    use actix_tls::accept::{
+        rustls::{reexports::ServerConfig, Acceptor, TlsStream},
+        TlsError,
+    };
+
+    use super::*;
+
     impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Response<AnyBody>> + 'static,
+        S::Error: Into<Response<BoxBody>> + 'static,
         S::Response: Into<Response<B>> + 'static,
         <S::Service as Service<Request>>::Future: 'static,
 
         B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
     {
-        /// Create Rustls based service
+        /// Create Rustls based service.
         pub fn rustls(
             self,
             mut config: ServerConfig,
@@ -177,19 +176,17 @@ mod rustls {
         > {
             let mut protos = vec![b"h2".to_vec()];
             protos.extend_from_slice(&config.alpn_protocols);
-            config.set_protocols(&protos);
+            config.alpn_protocols = protos;
 
             Acceptor::new(config)
-                .map_err(TlsError::Tls)
-                .map_init_err(|_| panic!())
-                .and_then(fn_factory(|| {
-                    ready(Ok::<_, S::InitError>(fn_service(
-                        |io: TlsStream<TcpStream>| {
-                            let peer_addr = io.get_ref().0.peer_addr().ok();
-                            ready(Ok((io, peer_addr)))
-                        },
-                    )))
-                }))
+                .map_init_err(|_| {
+                    unreachable!("TLS acceptor service factory does not error on init")
+                })
+                .map_err(TlsError::into_service_error)
+                .map(|io: TlsStream<TcpStream>| {
+                    let peer_addr = io.get_ref().0.peer_addr().ok();
+                    (io, peer_addr)
+                })
                 .and_then(self.map_err(TlsError::Service))
         }
     }
@@ -201,12 +198,11 @@ where
 
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
 
     B: MessageBody + 'static,
-    B::Error: Into<Box<dyn StdError>>,
 {
     type Response = ();
     type Error = DispatchError;
@@ -241,7 +237,7 @@ where
 impl<T, S, B> H2ServiceHandler<T, S, B>
 where
     S: Service<Request>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
@@ -264,27 +260,25 @@ impl<T, S, B> Service<(T, Option<net::SocketAddr>)> for H2ServiceHandler<T, S, B
 where
     T: AsyncRead + AsyncWrite + Unpin,
     S: Service<Request>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
-    B::Error: Into<Box<dyn StdError>>,
 {
     type Response = ();
     type Error = DispatchError;
     type Future = H2ServiceHandlerResponse<T, S, B>;
 
     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.flow.service.poll_ready(cx).map_err(|e| {
-            let e = e.into();
-            error!("Service readiness error: {:?}", e);
-            DispatchError::Service(e)
+        self.flow.service.poll_ready(cx).map_err(|err| {
+            let err = err.into();
+            error!("Service readiness error: {:?}", err);
+            DispatchError::Service(err)
         })
     }
 
     fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
-        let on_connect_data =
-            OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
+        let on_connect_data = OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
 
         H2ServiceHandlerResponse {
             state: State::Handshake(
@@ -292,7 +286,7 @@ where
                 Some(self.cfg.clone()),
                 addr,
                 on_connect_data,
-                h2_handshake(io),
+                handshake_with_timeout(io, &self.cfg),
             ),
         }
     }
@@ -303,21 +297,21 @@ where
     T: AsyncRead + AsyncWrite + Unpin,
     S::Future: 'static,
 {
-    Incoming(Dispatcher<T, S, B, (), ()>),
     Handshake(
         Option<Rc<HttpFlow<S, (), ()>>>,
         Option<ServiceConfig>,
         Option<net::SocketAddr>,
         OnConnectData,
-        H2Handshake<T, Bytes>,
+        HandshakeWithTimeout<T>,
     ),
+    Established(Dispatcher<T, S, B, (), ()>),
 }
 
 pub struct H2ServiceHandlerResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     S: Service<Request>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
@@ -329,40 +323,44 @@ impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     S: Service<Request>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S::Error: Into<Response<BoxBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
 {
     type Output = Result<(), DispatchError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         match self.state {
-            State::Incoming(ref mut disp) => Pin::new(disp).poll(cx),
             State::Handshake(
                 ref mut srv,
                 ref mut config,
                 ref peer_addr,
-                ref mut on_connect_data,
+                ref mut conn_data,
                 ref mut handshake,
             ) => match ready!(Pin::new(handshake).poll(cx)) {
-                Ok(conn) => {
-                    let on_connect_data = std::mem::take(on_connect_data);
-                    self.state = State::Incoming(Dispatcher::new(
-                        srv.take().unwrap(),
+                Ok((conn, timer)) => {
+                    let on_connect_data = mem::take(conn_data);
+
+                    self.state = State::Established(Dispatcher::new(
                         conn,
-                        on_connect_data,
+                        srv.take().unwrap(),
                         config.take().unwrap(),
                         *peer_addr,
+                        on_connect_data,
+                        timer,
                     ));
+
                     self.poll(cx)
                 }
+
                 Err(err) => {
                     trace!("H2 handshake error: {}", err);
-                    Poll::Ready(Err(err.into()))
+                    Poll::Ready(Err(err))
                 }
             },
+
+            State::Established(ref mut disp) => Pin::new(disp).poll(cx),
         }
     }
 }

actix-http/src/header/as_name.rs

@@ -1,11 +1,12 @@
-//! Helper trait for types that can be effectively borrowed as a [HeaderValue].
-//!
-//! [HeaderValue]: crate::http::HeaderValue
+//! Sealed [`AsHeaderName`] trait and implementations.
 
-use std::{borrow::Cow, str::FromStr};
+use std::{borrow::Cow, str::FromStr as _};
 
 use http::header::{HeaderName, InvalidHeaderName};
 
+/// Sealed trait implemented for types that can be effectively borrowed as a [`HeaderValue`].
+///
+/// [`HeaderValue`]: super::HeaderValue
 pub trait AsHeaderName: Sealed {}
 
 pub struct Seal;
@@ -15,6 +16,7 @@ pub trait Sealed {
 }
 
 impl Sealed for HeaderName {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         Ok(Cow::Borrowed(self))
     }
@@ -22,6 +24,7 @@ impl Sealed for HeaderName {
 impl AsHeaderName for HeaderName {}
 
 impl Sealed for &HeaderName {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         Ok(Cow::Borrowed(*self))
     }
@@ -29,6 +32,7 @@ impl Sealed for &HeaderName {
 impl AsHeaderName for &HeaderName {}
 
 impl Sealed for &str {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }
@@ -36,6 +40,7 @@ impl Sealed for &str {
 impl AsHeaderName for &str {}
 
 impl Sealed for String {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }
@@ -43,6 +48,7 @@ impl Sealed for String {
 impl AsHeaderName for String {}
 
 impl Sealed for &String {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }

actix-http/src/header/into_pair.rs

@@ -1,17 +1,20 @@
-use std::convert::TryFrom;
+//! [`TryIntoHeaderPair`] trait and implementations.
 
-use http::{
-    header::{HeaderName, InvalidHeaderName, InvalidHeaderValue},
-    Error as HttpError, HeaderValue,
+use std::convert::TryFrom as _;
+
+use super::{
+    Header, HeaderName, HeaderValue, InvalidHeaderName, InvalidHeaderValue, TryIntoHeaderValue,
 };
+use crate::error::HttpError;
 
-use super::{Header, IntoHeaderValue};
-
-/// Transforms structures into header K/V pairs for inserting into `HeaderMap`s.
-pub trait IntoHeaderPair: Sized {
+/// An interface for types that can be converted into a [`HeaderName`] + [`HeaderValue`] pair for
+/// insertion into a [`HeaderMap`].
+///
+/// [`HeaderMap`]: super::HeaderMap
+pub trait TryIntoHeaderPair: Sized {
     type Error: Into<HttpError>;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error>;
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error>;
 }
 
 #[derive(Debug)]
@@ -29,14 +32,14 @@ impl From<InvalidHeaderPart> for HttpError {
     }
 }
 
-impl<V> IntoHeaderPair for (HeaderName, V)
+impl<V> TryIntoHeaderPair for (HeaderName, V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
         let value = value
             .try_into_value()
@@ -45,14 +48,14 @@ where
     }
 }
 
-impl<V> IntoHeaderPair for (&HeaderName, V)
+impl<V> TryIntoHeaderPair for (&HeaderName, V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
         let value = value
             .try_into_value()
@@ -61,14 +64,14 @@ where
     }
 }
 
-impl<V> IntoHeaderPair for (&[u8], V)
+impl<V> TryIntoHeaderPair for (&[u8], V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
         let name = HeaderName::try_from(name).map_err(InvalidHeaderPart::Name)?;
         let value = value
@@ -78,14 +81,14 @@ where
     }
 }
 
-impl<V> IntoHeaderPair for (&str, V)
+impl<V> TryIntoHeaderPair for (&str, V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
         let name = HeaderName::try_from(name).map_err(InvalidHeaderPart::Name)?;
         let value = value
@@ -95,23 +98,25 @@ where
     }
 }
 
-impl<V> IntoHeaderPair for (String, V)
+impl<V> TryIntoHeaderPair for (String, V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    #[inline]
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
-        (name.as_str(), value).try_into_header_pair()
+        (name.as_str(), value).try_into_pair()
     }
 }
 
-impl<T: Header> IntoHeaderPair for T {
-    type Error = <T as IntoHeaderValue>::Error;
+impl<T: Header> TryIntoHeaderPair for T {
+    type Error = <T as TryIntoHeaderValue>::Error;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    #[inline]
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         Ok((T::name(), self.try_into_value()?))
     }
 }

actix-http/src/header/into_value.rs

@@ -1,11 +1,13 @@
-use std::convert::TryFrom;
+//! [`TryIntoHeaderValue`] trait and implementations.
+
+use std::convert::TryFrom as _;
 
 use bytes::Bytes;
 use http::{header::InvalidHeaderValue, Error as HttpError, HeaderValue};
 use mime::Mime;
 
-/// A trait for any object that can be Converted to a `HeaderValue`
-pub trait IntoHeaderValue: Sized {
+/// An interface for types that can be converted into a [`HeaderValue`].
+pub trait TryIntoHeaderValue: Sized {
     /// The type returned in the event of a conversion error.
     type Error: Into<HttpError>;
 
@@ -13,7 +15,7 @@ pub trait IntoHeaderValue: Sized {
     fn try_into_value(self) -> Result<HeaderValue, Self::Error>;
 }
 
-impl IntoHeaderValue for HeaderValue {
+impl TryIntoHeaderValue for HeaderValue {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -22,7 +24,7 @@ impl IntoHeaderValue for HeaderValue {
     }
 }
 
-impl IntoHeaderValue for &HeaderValue {
+impl TryIntoHeaderValue for &HeaderValue {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -31,7 +33,7 @@ impl IntoHeaderValue for &HeaderValue {
     }
 }
 
-impl IntoHeaderValue for &str {
+impl TryIntoHeaderValue for &str {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -40,7 +42,7 @@ impl IntoHeaderValue for &str {
     }
 }
 
-impl IntoHeaderValue for &[u8] {
+impl TryIntoHeaderValue for &[u8] {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -49,7 +51,7 @@ impl IntoHeaderValue for &[u8] {
     }
 }
 
-impl IntoHeaderValue for Bytes {
+impl TryIntoHeaderValue for Bytes {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -58,7 +60,7 @@ impl IntoHeaderValue for Bytes {
     }
 }
 
-impl IntoHeaderValue for Vec<u8> {
+impl TryIntoHeaderValue for Vec<u8> {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -67,7 +69,7 @@ impl IntoHeaderValue for Vec<u8> {
     }
 }
 
-impl IntoHeaderValue for String {
+impl TryIntoHeaderValue for String {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -76,7 +78,7 @@ impl IntoHeaderValue for String {
     }
 }
 
-impl IntoHeaderValue for usize {
+impl TryIntoHeaderValue for usize {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -85,7 +87,7 @@ impl IntoHeaderValue for usize {
     }
 }
 
-impl IntoHeaderValue for i64 {
+impl TryIntoHeaderValue for i64 {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -94,7 +96,7 @@ impl IntoHeaderValue for i64 {
     }
 }
 
-impl IntoHeaderValue for u64 {
+impl TryIntoHeaderValue for u64 {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -103,7 +105,7 @@ impl IntoHeaderValue for u64 {
     }
 }
 
-impl IntoHeaderValue for i32 {
+impl TryIntoHeaderValue for i32 {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -112,7 +114,7 @@ impl IntoHeaderValue for i32 {
     }
 }
 
-impl IntoHeaderValue for u32 {
+impl TryIntoHeaderValue for u32 {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -121,7 +123,7 @@ impl IntoHeaderValue for u32 {
     }
 }
 
-impl IntoHeaderValue for Mime {
+impl TryIntoHeaderValue for Mime {
     type Error = InvalidHeaderValue;
 
     #[inline]

actix-http/src/header/map.rs

@@ -1,6 +1,6 @@
 //! A multi-value [`HeaderMap`] and its iterators.
 
-use std::{borrow::Cow, collections::hash_map, ops};
+use std::{borrow::Cow, collections::hash_map, iter, ops};
 
 use ahash::AHashMap;
 use http::header::{HeaderName, HeaderValue};
@@ -14,7 +14,7 @@ use crate::header::AsHeaderName;
 ///
 /// # Examples
 /// ```
-/// use actix_http::http::{header, HeaderMap, HeaderValue};
+/// use actix_http::header::{self, HeaderMap, HeaderValue};
 ///
 /// let mut map = HeaderMap::new();
 ///
@@ -75,7 +75,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::HeaderMap;
+    /// # use actix_http::header::HeaderMap;
     /// let map = HeaderMap::new();
     ///
     /// assert!(map.is_empty());
@@ -92,7 +92,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::HeaderMap;
+    /// # use actix_http::header::HeaderMap;
     /// let map = HeaderMap::with_capacity(16);
     ///
     /// assert!(map.is_empty());
@@ -123,12 +123,11 @@ impl HeaderMap {
         let mut map = HeaderMap::with_capacity(capacity);
         map.append(first_name.clone(), first_value);
 
-        let (map, _) =
-            drain.fold((map, first_name), |(mut map, prev_name), (name, value)| {
-                let name = name.unwrap_or(prev_name);
-                map.append(name.clone(), value);
-                (map, name)
-            });
+        let (map, _) = drain.fold((map, first_name), |(mut map, prev_name), (name, value)| {
+            let name = name.unwrap_or(prev_name);
+            map.append(name.clone(), value);
+            (map, name)
+        });
 
         map
     }
@@ -139,7 +138,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     /// assert_eq!(map.len(), 0);
     ///
@@ -162,7 +161,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     /// assert_eq!(map.len_keys(), 0);
     ///
@@ -181,7 +180,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     /// assert!(map.is_empty());
     ///
@@ -198,7 +197,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
@@ -231,7 +230,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// map.insert(header::SET_COOKIE, HeaderValue::from_static("one=1"));
@@ -249,7 +248,7 @@ impl HeaderMap {
     /// assert!(map.get("INVALID HEADER NAME").is_none());
     /// ```
     pub fn get(&self, key: impl AsHeaderName) -> Option<&HeaderValue> {
-        self.get_value(key).map(|val| val.first())
+        self.get_value(key).map(Value::first)
     }
 
     /// Returns a mutable reference to the _first_ value associated a header name.
@@ -264,7 +263,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// map.insert(header::SET_COOKIE, HeaderValue::from_static("one=1"));
@@ -280,20 +279,20 @@ impl HeaderMap {
     /// ```
     pub fn get_mut(&mut self, key: impl AsHeaderName) -> Option<&mut HeaderValue> {
         match key.try_as_name(super::as_name::Seal).ok()? {
-            Cow::Borrowed(name) => self.inner.get_mut(name).map(|v| v.first_mut()),
-            Cow::Owned(name) => self.inner.get_mut(&name).map(|v| v.first_mut()),
+            Cow::Borrowed(name) => self.inner.get_mut(name).map(Value::first_mut),
+            Cow::Owned(name) => self.inner.get_mut(&name).map(Value::first_mut),
         }
     }
 
     /// Returns an iterator over all values associated with a header name.
     ///
     /// The returned iterator does not incur any allocations and will yield no items if there are no
-    /// values associated with the key. Iteration order is **not** guaranteed to be the same as
+    /// values associated with the key. Iteration order is guaranteed to be the same as
     /// insertion order.
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// let mut none_iter = map.get_all(header::ORIGIN);
@@ -307,8 +306,11 @@ impl HeaderMap {
     /// assert_eq!(set_cookies_iter.next().unwrap(), "two=2");
     /// assert!(set_cookies_iter.next().is_none());
     /// ```
-    pub fn get_all(&self, key: impl AsHeaderName) -> GetAll<'_> {
-        GetAll::new(self.get_value(key))
+    pub fn get_all(&self, key: impl AsHeaderName) -> std::slice::Iter<'_, HeaderValue> {
+        match self.get_value(key) {
+            Some(value) => value.iter(),
+            None => (&[]).iter(),
+        }
     }
 
     // TODO: get_all_mut ?
@@ -319,7 +321,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     /// assert!(!map.contains_key(header::ACCEPT));
     ///
@@ -334,7 +336,7 @@ impl HeaderMap {
         }
     }
 
-    /// Inserts a name-value pair into the map.
+    /// Inserts (overrides) a name-value pair in the map.
     ///
     /// If the map already contained this key, the new value is associated with the key and all
     /// previous values are removed and returned as a `Removed` iterator. The key is not updated;
@@ -342,7 +344,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
@@ -355,12 +357,25 @@ impl HeaderMap {
     ///
     /// assert_eq!(map.len(), 1);
     /// ```
+    ///
+    /// A convenience method is provided on the returned iterator to check if the insertion replaced
+    /// any values.
+    /// ```
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// let removed = map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
+    /// assert!(removed.is_empty());
+    ///
+    /// let removed = map.insert(header::ACCEPT, HeaderValue::from_static("text/html"));
+    /// assert!(!removed.is_empty());
+    /// ```
     pub fn insert(&mut self, key: HeaderName, val: HeaderValue) -> Removed {
         let value = self.inner.insert(key, Value::one(val));
         Removed::new(value)
     }
 
-    /// Inserts a name-value pair into the map.
+    /// Appends a name-value pair to the map.
     ///
     /// If the map already contained this key, the new value is added to the list of values
     /// currently associated with the key. The key is not updated; this matters for types that can
@@ -368,7 +383,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// map.append(header::HOST, HeaderValue::from_static("example.com"));
@@ -393,9 +408,12 @@ impl HeaderMap {
 
     /// Removes all headers for a particular header name from the map.
     ///
+    /// Providing an invalid header names (as a string argument) will have no effect and return
+    /// without error.
+    ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// map.append(header::SET_COOKIE, HeaderValue::from_static("one=1"));
@@ -409,6 +427,21 @@ impl HeaderMap {
     /// assert!(removed.next().is_none());
     ///
     /// assert!(map.is_empty());
+    /// ```
+    ///
+    /// A convenience method is provided on the returned iterator to check if the `remove` call
+    /// actually removed any values.
+    /// ```
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// let removed = map.remove("accept");
+    /// assert!(removed.is_empty());
+    ///
+    /// map.insert(header::ACCEPT, HeaderValue::from_static("text/html"));
+    /// let removed = map.remove("accept");
+    /// assert!(!removed.is_empty());
+    /// ```
     pub fn remove(&mut self, key: impl AsHeaderName) -> Removed {
         let value = match key.try_as_name(super::as_name::Seal) {
             Ok(Cow::Borrowed(name)) => self.inner.remove(name),
@@ -428,7 +461,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::HeaderMap;
+    /// # use actix_http::header::HeaderMap;
     /// let map = HeaderMap::with_capacity(16);
     ///
     /// assert!(map.is_empty());
@@ -448,7 +481,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::HeaderMap;
+    /// # use actix_http::header::HeaderMap;
     /// let mut map = HeaderMap::with_capacity(2);
     /// assert!(map.capacity() >= 2);
     ///
@@ -468,7 +501,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// let mut iter = map.iter();
@@ -500,7 +533,7 @@ impl HeaderMap {
     ///
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// let mut iter = map.keys();
@@ -528,7 +561,7 @@ impl HeaderMap {
     /// Keeps the allocated memory for reuse.
     /// # Examples
     /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
     /// let mut map = HeaderMap::new();
     ///
     /// let mut iter = map.drain();
@@ -550,7 +583,8 @@ impl HeaderMap {
     }
 }
 
-/// Note that this implementation will clone a [HeaderName] for each value.
+/// Note that this implementation will clone a [HeaderName] for each value. Consider using
+/// [`drain`](Self::drain) to control header name cloning.
 impl IntoIterator for HeaderMap {
     type Item = (HeaderName, HeaderValue);
     type IntoIter = IntoIter;
@@ -571,60 +605,32 @@ impl<'a> IntoIterator for &'a HeaderMap {
     }
 }
 
-/// Iterator for all values with the same header name.
+/// Iterator over removed, owned values with the same associated name.
 ///
-/// See [`HeaderMap::get_all`].
-#[derive(Debug)]
-pub struct GetAll<'a> {
-    idx: usize,
-    value: Option<&'a Value>,
-}
-
-impl<'a> GetAll<'a> {
-    fn new(value: Option<&'a Value>) -> Self {
-        Self { idx: 0, value }
-    }
-}
-
-impl<'a> Iterator for GetAll<'a> {
-    type Item = &'a HeaderValue;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let val = self.value?;
-
-        match val.get(self.idx) {
-            Some(val) => {
-                self.idx += 1;
-                Some(val)
-            }
-            None => {
-                // current index is none; remove value to fast-path future next calls
-                self.value = None;
-                None
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        match self.value {
-            Some(val) => (val.len(), Some(val.len())),
-            None => (0, Some(0)),
-        }
-    }
-}
-
-/// Iterator for owned [`HeaderValue`]s with the same associated [`HeaderName`] returned from methods
-/// on [`HeaderMap`] that remove or replace items.
+/// Returned from methods that remove or replace items. See [`HeaderMap::insert`]
+/// and [`HeaderMap::remove`].
 #[derive(Debug)]
 pub struct Removed {
     inner: Option<smallvec::IntoIter<[HeaderValue; 4]>>,
 }
 
-impl<'a> Removed {
+impl Removed {
     fn new(value: Option<Value>) -> Self {
         let inner = value.map(|value| value.inner.into_iter());
         Self { inner }
     }
+
+    /// Returns true if iterator contains no elements, without consuming it.
+    ///
+    /// If called immediately after [`HeaderMap::insert`] or [`HeaderMap::remove`], it will indicate
+    /// wether any items were actually replaced or removed, respectively.
+    pub fn is_empty(&self) -> bool {
+        match self.inner {
+            // size hint lower bound of smallvec is the correct length
+            Some(ref iter) => iter.size_hint().0 == 0,
+            None => true,
+        }
+    }
 }
 
 impl Iterator for Removed {
@@ -644,7 +650,11 @@ impl Iterator for Removed {
     }
 }
 
-/// Iterator over all [`HeaderName`]s in the map.
+impl ExactSizeIterator for Removed {}
+
+impl iter::FusedIterator for Removed {}
+
+/// Iterator over all names in the map.
 #[derive(Debug)]
 pub struct Keys<'a>(hash_map::Keys<'a, HeaderName, Value>);
 
@@ -662,6 +672,11 @@ impl<'a> Iterator for Keys<'a> {
     }
 }
 
+impl ExactSizeIterator for Keys<'_> {}
+
+impl iter::FusedIterator for Keys<'_> {}
+
+/// Iterator over borrowed name-value pairs.
 #[derive(Debug)]
 pub struct Iter<'a> {
     inner: hash_map::Iter<'a, HeaderName, Value>,
@@ -684,7 +699,7 @@ impl<'a> Iterator for Iter<'a> {
 
     fn next(&mut self) -> Option<Self::Item> {
         // handle in-progress multi value lists first
-        if let Some((ref name, ref mut vals)) = self.multi_inner {
+        if let Some((name, ref mut vals)) = self.multi_inner {
             match vals.get(self.multi_idx) {
                 Some(val) => {
                     self.multi_idx += 1;
@@ -713,6 +728,10 @@ impl<'a> Iterator for Iter<'a> {
     }
 }
 
+impl ExactSizeIterator for Iter<'_> {}
+
+impl iter::FusedIterator for Iter<'_> {}
+
 /// Iterator over drained name-value pairs.
 ///
 /// Iterator items are `(Option<HeaderName>, HeaderValue)` to avoid cloning.
@@ -764,6 +783,10 @@ impl<'a> Iterator for Drain<'a> {
     }
 }
 
+impl ExactSizeIterator for Drain<'_> {}
+
+impl iter::FusedIterator for Drain<'_> {}
+
 /// Iterator over owned name-value pairs.
 ///
 /// Implementation necessarily clones header names for each value.
@@ -814,12 +837,27 @@ impl Iterator for IntoIter {
     }
 }
 
+impl ExactSizeIterator for IntoIter {}
+
+impl iter::FusedIterator for IntoIter {}
+
 #[cfg(test)]
 mod tests {
+    use std::iter::FusedIterator;
+
     use http::header;
+    use static_assertions::assert_impl_all;
 
     use super::*;
 
+    assert_impl_all!(HeaderMap: IntoIterator);
+    assert_impl_all!(Keys<'_>: Iterator, ExactSizeIterator, FusedIterator);
+    assert_impl_all!(std::slice::Iter<'_, HeaderValue>: Iterator, ExactSizeIterator, FusedIterator);
+    assert_impl_all!(Removed: Iterator, ExactSizeIterator, FusedIterator);
+    assert_impl_all!(Iter<'_>: Iterator, ExactSizeIterator, FusedIterator);
+    assert_impl_all!(IntoIter: Iterator, ExactSizeIterator, FusedIterator);
+    assert_impl_all!(Drain<'_>: Iterator, ExactSizeIterator, FusedIterator);
+
     #[test]
     fn create() {
         let map = HeaderMap::new();
@@ -945,6 +983,56 @@ mod tests {
         assert_eq!(vals.next(), removed.next().as_ref());
     }
 
+    #[test]
+    fn get_all_iteration_order_matches_insertion_order() {
+        let mut map = HeaderMap::new();
+
+        let mut vals = map.get_all(header::COOKIE);
+        assert!(vals.next().is_none());
+
+        map.append(header::COOKIE, HeaderValue::from_static("1"));
+        let mut vals = map.get_all(header::COOKIE);
+        assert_eq!(vals.next().unwrap().as_bytes(), b"1");
+        assert!(vals.next().is_none());
+
+        map.append(header::COOKIE, HeaderValue::from_static("2"));
+        let mut vals = map.get_all(header::COOKIE);
+        assert_eq!(vals.next().unwrap().as_bytes(), b"1");
+        assert_eq!(vals.next().unwrap().as_bytes(), b"2");
+        assert!(vals.next().is_none());
+
+        map.append(header::COOKIE, HeaderValue::from_static("3"));
+        map.append(header::COOKIE, HeaderValue::from_static("4"));
+        map.append(header::COOKIE, HeaderValue::from_static("5"));
+        let mut vals = map.get_all(header::COOKIE);
+        assert_eq!(vals.next().unwrap().as_bytes(), b"1");
+        assert_eq!(vals.next().unwrap().as_bytes(), b"2");
+        assert_eq!(vals.next().unwrap().as_bytes(), b"3");
+        assert_eq!(vals.next().unwrap().as_bytes(), b"4");
+        assert_eq!(vals.next().unwrap().as_bytes(), b"5");
+        assert!(vals.next().is_none());
+
+        let _ = map.insert(header::COOKIE, HeaderValue::from_static("6"));
+        let mut vals = map.get_all(header::COOKIE);
+        assert_eq!(vals.next().unwrap().as_bytes(), b"6");
+        assert!(vals.next().is_none());
+
+        let _ = map.insert(header::COOKIE, HeaderValue::from_static("7"));
+        let _ = map.insert(header::COOKIE, HeaderValue::from_static("8"));
+        let mut vals = map.get_all(header::COOKIE);
+        assert_eq!(vals.next().unwrap().as_bytes(), b"8");
+        assert!(vals.next().is_none());
+
+        map.append(header::COOKIE, HeaderValue::from_static("9"));
+        let mut vals = map.get_all(header::COOKIE);
+        assert_eq!(vals.next().unwrap().as_bytes(), b"8");
+        assert_eq!(vals.next().unwrap().as_bytes(), b"9");
+        assert!(vals.next().is_none());
+
+        // check for fused-ness
+        assert!(vals.next().is_none());
+    }
+
     fn owned_pair<'a>(
         (name, val): (&'a HeaderName, &'a HeaderValue),
     ) -> (HeaderName, HeaderValue) {

actix-http/src/header/mod.rs

@@ -11,53 +11,50 @@ pub use http::header::{
 pub use http::header::{
     ACCEPT, ACCEPT_CHARSET, ACCEPT_ENCODING, ACCEPT_LANGUAGE, ACCEPT_RANGES,
     ACCESS_CONTROL_ALLOW_CREDENTIALS, ACCESS_CONTROL_ALLOW_HEADERS,
-    ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
-    ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_MAX_AGE,
-    ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD, AGE, ALLOW, ALT_SVC,
-    AUTHORIZATION, CACHE_CONTROL, CONNECTION, CONTENT_DISPOSITION, CONTENT_ENCODING,
-    CONTENT_LANGUAGE, CONTENT_LENGTH, CONTENT_LOCATION, CONTENT_RANGE,
-    CONTENT_SECURITY_POLICY, CONTENT_SECURITY_POLICY_REPORT_ONLY, CONTENT_TYPE, COOKIE,
-    DATE, DNT, ETAG, EXPECT, EXPIRES, FORWARDED, FROM, HOST, IF_MATCH,
-    IF_MODIFIED_SINCE, IF_NONE_MATCH, IF_RANGE, IF_UNMODIFIED_SINCE, LAST_MODIFIED,
-    LINK, LOCATION, MAX_FORWARDS, ORIGIN, PRAGMA, PROXY_AUTHENTICATE,
-    PROXY_AUTHORIZATION, PUBLIC_KEY_PINS, PUBLIC_KEY_PINS_REPORT_ONLY, RANGE, REFERER,
-    REFERRER_POLICY, REFRESH, RETRY_AFTER, SEC_WEBSOCKET_ACCEPT,
-    SEC_WEBSOCKET_EXTENSIONS, SEC_WEBSOCKET_KEY, SEC_WEBSOCKET_PROTOCOL,
+    ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN, ACCESS_CONTROL_EXPOSE_HEADERS,
+    ACCESS_CONTROL_MAX_AGE, ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD, AGE,
+    ALLOW, ALT_SVC, AUTHORIZATION, CACHE_CONTROL, CONNECTION, CONTENT_DISPOSITION,
+    CONTENT_ENCODING, CONTENT_LANGUAGE, CONTENT_LENGTH, CONTENT_LOCATION, CONTENT_RANGE,
+    CONTENT_SECURITY_POLICY, CONTENT_SECURITY_POLICY_REPORT_ONLY, CONTENT_TYPE, COOKIE, DATE,
+    DNT, ETAG, EXPECT, EXPIRES, FORWARDED, FROM, HOST, IF_MATCH, IF_MODIFIED_SINCE,
+    IF_NONE_MATCH, IF_RANGE, IF_UNMODIFIED_SINCE, LAST_MODIFIED, LINK, LOCATION, MAX_FORWARDS,
+    ORIGIN, PRAGMA, PROXY_AUTHENTICATE, PROXY_AUTHORIZATION, PUBLIC_KEY_PINS,
+    PUBLIC_KEY_PINS_REPORT_ONLY, RANGE, REFERER, REFERRER_POLICY, REFRESH, RETRY_AFTER,
+    SEC_WEBSOCKET_ACCEPT, SEC_WEBSOCKET_EXTENSIONS, SEC_WEBSOCKET_KEY, SEC_WEBSOCKET_PROTOCOL,
     SEC_WEBSOCKET_VERSION, SERVER, SET_COOKIE, STRICT_TRANSPORT_SECURITY, TE, TRAILER,
-    TRANSFER_ENCODING, UPGRADE, UPGRADE_INSECURE_REQUESTS, USER_AGENT, VARY, VIA,
-    WARNING, WWW_AUTHENTICATE, X_CONTENT_TYPE_OPTIONS, X_DNS_PREFETCH_CONTROL,
-    X_FRAME_OPTIONS, X_XSS_PROTECTION,
+    TRANSFER_ENCODING, UPGRADE, UPGRADE_INSECURE_REQUESTS, USER_AGENT, VARY, VIA, WARNING,
+    WWW_AUTHENTICATE, X_CONTENT_TYPE_OPTIONS, X_DNS_PREFETCH_CONTROL, X_FRAME_OPTIONS,
+    X_XSS_PROTECTION,
 };
 
-use crate::error::ParseError;
-use crate::HttpMessage;
+use crate::{error::ParseError, HttpMessage};
 
 mod as_name;
 mod into_pair;
 mod into_value;
+pub mod map;
+mod shared;
 mod utils;
 
-pub(crate) mod map;
-mod shared;
-
-#[doc(hidden)]
-pub use self::shared::*;
-
 pub use self::as_name::AsHeaderName;
-pub use self::into_pair::IntoHeaderPair;
-pub use self::into_value::IntoHeaderValue;
-#[doc(hidden)]
-pub use self::map::GetAll;
+pub use self::into_pair::TryIntoHeaderPair;
+pub use self::into_value::TryIntoHeaderValue;
 pub use self::map::HeaderMap;
-pub use self::utils::*;
+pub use self::shared::{
+    parse_extended_value, q, Charset, ContentEncoding, ExtendedValue, HttpDate, LanguageTag,
+    Quality, QualityItem,
+};
+pub use self::utils::{
+    fmt_comma_delimited, from_comma_delimited, from_one_raw_str, http_percent_encode,
+};
 
-/// A trait for any object that already represents a valid header field and value.
-pub trait Header: IntoHeaderValue {
+/// An interface for types that already represent a valid header.
+pub trait Header: TryIntoHeaderValue {
     /// Returns the name of the header field
     fn name() -> HeaderName;
 
     /// Parse a header
-    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError>;
+    fn parse<M: HttpMessage>(msg: &M) -> Result<Self, ParseError>;
 }
 
 /// Convert `http::HeaderMap` to our `HeaderMap`.
@@ -68,7 +65,7 @@ impl From<http::HeaderMap> for HeaderMap {
 }
 
 /// This encode set is used for HTTP header values and is defined at
-/// https://tools.ietf.org/html/rfc5987#section-3.2.
+/// <https://datatracker.ietf.org/doc/html/rfc5987#section-3.2>.
 pub(crate) const HTTP_VALUE: &AsciiSet = &CONTROLS
     .add(b' ')
     .add(b'"')

actix-http/src/header/shared/charset.rs

@@ -1,14 +1,13 @@
-use std::fmt::{self, Display};
-use std::str::FromStr;
+use std::{fmt, str};
 
 use self::Charset::*;
 
-/// A Mime charset.
+/// A MIME character set.
 ///
 /// The string representation is normalized to upper case.
 ///
 /// See <http://www.iana.org/assignments/character-sets/character-sets.xhtml>.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[allow(non_camel_case_types)]
 pub enum Charset {
     /// US ASCII
@@ -88,20 +87,20 @@ impl Charset {
             Iso_8859_8_E => "ISO-8859-8-E",
             Iso_8859_8_I => "ISO-8859-8-I",
             Gb2312 => "GB2312",
-            Big5 => "big5",
+            Big5 => "Big5",
             Koi8_R => "KOI8-R",
             Ext(ref s) => s,
         }
     }
 }
 
-impl Display for Charset {
+impl fmt::Display for Charset {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(self.label())
     }
 }
 
-impl FromStr for Charset {
+impl str::FromStr for Charset {
     type Err = crate::Error;
 
     fn from_str(s: &str) -> Result<Charset, crate::Error> {
@@ -128,7 +127,7 @@ impl FromStr for Charset {
             "ISO-8859-8-E" => Iso_8859_8_E,
             "ISO-8859-8-I" => Iso_8859_8_I,
             "GB2312" => Gb2312,
-            "big5" => Big5,
+            "BIG5" => Big5,
             "KOI8-R" => Koi8_R,
             s => Ext(s.to_owned()),
         })

actix-http/src/header/shared/content_encoding.rs

@@ -1,15 +1,27 @@
-use std::{convert::Infallible, str::FromStr};
+use std::{convert::TryFrom, str::FromStr};
 
+use derive_more::{Display, Error};
 use http::header::InvalidHeaderValue;
 
 use crate::{
     error::ParseError,
-    header::{self, from_one_raw_str, Header, HeaderName, HeaderValue, IntoHeaderValue},
+    header::{self, from_one_raw_str, Header, HeaderName, HeaderValue, TryIntoHeaderValue},
     HttpMessage,
 };
 
+/// Error returned when a content encoding is unknown.
+#[derive(Debug, Display, Error)]
+#[display(fmt = "unsupported content encoding")]
+pub struct ContentEncodingParseError;
+
 /// Represents a supported content encoding.
-#[derive(Copy, Clone, PartialEq, Debug)]
+///
+/// Includes a commonly-used subset of media types appropriate for use as HTTP content encodings.
+/// See [IANA HTTP Content Coding Registry].
+///
+/// [IANA HTTP Content Coding Registry]: https://www.iana.org/assignments/http-parameters/http-parameters.xhtml
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[non_exhaustive]
 pub enum ContentEncoding {
     /// Automatically select encoding based on encoding negotiation.
     Auto,
@@ -23,7 +35,7 @@ pub enum ContentEncoding {
     /// Gzip algorithm.
     Gzip,
 
-    // Zstd algorithm.
+    /// Zstd algorithm.
     Zstd,
 
     /// Indicates the identity function (i.e. no compression, nor modification).
@@ -33,13 +45,13 @@ pub enum ContentEncoding {
 impl ContentEncoding {
     /// Is the content compressed?
     #[inline]
-    pub fn is_compression(self) -> bool {
+    pub const fn is_compression(self) -> bool {
         matches!(self, ContentEncoding::Identity | ContentEncoding::Auto)
     }
 
-    /// Convert content encoding to string
+    /// Convert content encoding to string.
     #[inline]
-    pub fn as_str(self) -> &'static str {
+    pub const fn as_str(self) -> &'static str {
         match self {
             ContentEncoding::Br => "br",
             ContentEncoding::Gzip => "gzip",
@@ -48,18 +60,6 @@ impl ContentEncoding {
             ContentEncoding::Identity | ContentEncoding::Auto => "identity",
         }
     }
-
-    /// Default Q-factor (quality) value.
-    #[inline]
-    pub fn quality(self) -> f64 {
-        match self {
-            ContentEncoding::Br => 1.1,
-            ContentEncoding::Gzip => 1.0,
-            ContentEncoding::Deflate => 0.9,
-            ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
-            ContentEncoding::Zstd => 0.0,
-        }
-    }
 }
 
 impl Default for ContentEncoding {
@@ -69,32 +69,34 @@ impl Default for ContentEncoding {
 }
 
 impl FromStr for ContentEncoding {
-    type Err = Infallible;
+    type Err = ContentEncodingParseError;
 
     fn from_str(val: &str) -> Result<Self, Self::Err> {
-        Ok(Self::from(val))
-    }
-}
-
-impl From<&str> for ContentEncoding {
-    fn from(val: &str) -> ContentEncoding {
         let val = val.trim();
 
         if val.eq_ignore_ascii_case("br") {
-            ContentEncoding::Br
+            Ok(ContentEncoding::Br)
         } else if val.eq_ignore_ascii_case("gzip") {
-            ContentEncoding::Gzip
+            Ok(ContentEncoding::Gzip)
         } else if val.eq_ignore_ascii_case("deflate") {
-            ContentEncoding::Deflate
+            Ok(ContentEncoding::Deflate)
         } else if val.eq_ignore_ascii_case("zstd") {
-            ContentEncoding::Zstd
+            Ok(ContentEncoding::Zstd)
         } else {
-            ContentEncoding::default()
+            Err(ContentEncodingParseError)
         }
     }
 }
 
-impl IntoHeaderValue for ContentEncoding {
+impl TryFrom<&str> for ContentEncoding {
+    type Error = ContentEncodingParseError;
+
+    fn try_from(val: &str) -> Result<Self, Self::Error> {
+        val.parse()
+    }
+}
+
+impl TryIntoHeaderValue for ContentEncoding {
     type Error = InvalidHeaderValue;
 
     fn try_into_value(self) -> Result<http::HeaderValue, Self::Error> {

actix-http/src/header/shared/extended.rs

@@ -1,17 +1,17 @@
+//! Originally taken from `hyper::header::parsing`.
+
 use std::{fmt, str::FromStr};
 
 use language_tags::LanguageTag;
 
 use crate::header::{Charset, HTTP_VALUE};
 
-// From hyper v0.11.27 src/header/parsing.rs
-
 /// The value part of an extended parameter consisting of three parts:
 /// - The REQUIRED character set name (`charset`).
 /// - The OPTIONAL language information (`language_tag`).
 /// - A character sequence representing the actual value (`value`), separated by single quotes.
 ///
-/// It is defined in [RFC 5987](https://tools.ietf.org/html/rfc5987#section-3.2).
+/// It is defined in [RFC 5987 §3.2](https://datatracker.ietf.org/doc/html/rfc5987#section-3.2).
 #[derive(Clone, Debug, PartialEq)]
 pub struct ExtendedValue {
     /// The character set that is used to encode the `value` to a string.
@@ -24,17 +24,17 @@ pub struct ExtendedValue {
     pub value: Vec<u8>,
 }
 
-/// Parses extended header parameter values (`ext-value`), as defined in
-/// [RFC 5987](https://tools.ietf.org/html/rfc5987#section-3.2).
+/// Parses extended header parameter values (`ext-value`), as defined
+/// in [RFC 5987 §3.2](https://datatracker.ietf.org/doc/html/rfc5987#section-3.2).
 ///
 /// Extended values are denoted by parameter names that end with `*`.
 ///
 /// ## ABNF
 ///
-/// ```text
+/// ```plain
 /// ext-value     = charset  "'" [ language ] "'" value-chars
 ///               ; like RFC 2231's <extended-initial-value>
-///               ; (see [RFC2231], Section 7)
+///               ; (see [RFC 2231 §7])
 ///
 /// charset       = "UTF-8" / "ISO-8859-1" / mime-charset
 ///
@@ -43,25 +43,27 @@ pub struct ExtendedValue {
 ///               / "!" / "#" / "$" / "%" / "&"
 ///               / "+" / "-" / "^" / "_" / "`"
 ///               / "{" / "}" / "~"
-///               ; as <mime-charset> in Section 2.3 of [RFC2978]
+///               ; as <mime-charset> in [RFC 2978 §2.3]
 ///               ; except that the single quote is not included
 ///               ; SHOULD be registered in the IANA charset registry
 ///
-/// language      = <Language-Tag, defined in [RFC5646], Section 2.1>
+/// language      = <Language-Tag, defined in [RFC 5646 §2.1]>
 ///
 /// value-chars   = *( pct-encoded / attr-char )
 ///
 /// pct-encoded   = "%" HEXDIG HEXDIG
-///               ; see [RFC3986], Section 2.1
+///               ; see [RFC 3986 §2.1]
 ///
 /// attr-char     = ALPHA / DIGIT
 ///               / "!" / "#" / "$" / "&" / "+" / "-" / "."
 ///               / "^" / "_" / "`" / "|" / "~"
 ///               ; token except ( "*" / "'" / "%" )
 /// ```
-pub fn parse_extended_value(
-    val: &str,
-) -> Result<ExtendedValue, crate::error::ParseError> {
+///
+/// [RFC 2231 §7]: https://datatracker.ietf.org/doc/html/rfc2231#section-7
+/// [RFC 2978 §2.3]: https://datatracker.ietf.org/doc/html/rfc2978#section-2.3
+/// [RFC 3986 §2.1]: https://datatracker.ietf.org/doc/html/rfc5646#section-2.1
+pub fn parse_extended_value(val: &str) -> Result<ExtendedValue, crate::error::ParseError> {
     // Break into three pieces separated by the single-quote character
     let mut parts = val.splitn(3, '\'');
 
@@ -96,8 +98,7 @@ pub fn parse_extended_value(
 
 impl fmt::Display for ExtendedValue {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let encoded_value =
-            percent_encoding::percent_encode(&self.value[..], HTTP_VALUE);
+        let encoded_value = percent_encoding::percent_encode(&self.value[..], HTTP_VALUE);
         if let Some(ref lang) = self.language_tag {
             write!(f, "{}'{}'{}", self.charset, lang, encoded_value)
         } else {
@@ -139,8 +140,8 @@ mod tests {
         assert!(extended_value.language_tag.is_none());
         assert_eq!(
             vec![
-                194, 163, b' ', b'a', b'n', b'd', b' ', 226, 130, 172, b' ', b'r', b'a',
-                b't', b'e', b's',
+                194, 163, b' ', b'a', b'n', b'd', b' ', 226, 130, 172, b' ', b'r', b'a', b't',
+                b'e', b's',
             ],
             extended_value.value
         );
@@ -181,8 +182,8 @@ mod tests {
             charset: Charset::Ext("UTF-8".to_string()),
             language_tag: None,
             value: vec![
-                194, 163, b' ', b'a', b'n', b'd', b' ', 226, 130, 172, b' ', b'r', b'a',
-                b't', b'e', b's',
+                194, 163, b' ', b'a', b'n', b'd', b' ', 226, 130, 172, b' ', b'r', b'a', b't',
+                b'e', b's',
             ],
         };
         assert_eq!(

actix-http/src/header/shared/http_date.rs

@@ -0,0 +1,82 @@
+use std::{fmt, io::Write, str::FromStr, time::SystemTime};
+
+use bytes::BytesMut;
+use http::header::{HeaderValue, InvalidHeaderValue};
+
+use crate::{
+    config::DATE_VALUE_LENGTH, error::ParseError, header::TryIntoHeaderValue,
+    helpers::MutWriter,
+};
+
+/// A timestamp with HTTP-style formatting and parsing.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct HttpDate(SystemTime);
+
+impl FromStr for HttpDate {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<HttpDate, ParseError> {
+        match httpdate::parse_http_date(s) {
+            Ok(sys_time) => Ok(HttpDate(sys_time)),
+            Err(_) => Err(ParseError::Header),
+        }
+    }
+}
+
+impl fmt::Display for HttpDate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let date_str = httpdate::fmt_http_date(self.0);
+        f.write_str(&date_str)
+    }
+}
+
+impl TryIntoHeaderValue for HttpDate {
+    type Error = InvalidHeaderValue;
+
+    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
+        let mut buf = BytesMut::with_capacity(DATE_VALUE_LENGTH);
+        let mut wrt = MutWriter(&mut buf);
+
+        // unwrap: date output is known to be well formed and of known length
+        write!(wrt, "{}", httpdate::fmt_http_date(self.0)).unwrap();
+
+        HeaderValue::from_maybe_shared(buf.split().freeze())
+    }
+}
+
+impl From<SystemTime> for HttpDate {
+    fn from(sys_time: SystemTime) -> HttpDate {
+        HttpDate(sys_time)
+    }
+}
+
+impl From<HttpDate> for SystemTime {
+    fn from(HttpDate(sys_time): HttpDate) -> SystemTime {
+        sys_time
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use super::*;
+
+    #[test]
+    fn date_header() {
+        macro_rules! assert_parsed_date {
+            ($case:expr, $exp:expr) => {
+                assert_eq!($case.parse::<HttpDate>().unwrap(), $exp);
+            };
+        }
+
+        // 784198117 = SystemTime::from(datetime!(1994-11-07 08:48:37).assume_utc()).duration_since(SystemTime::UNIX_EPOCH));
+        let nov_07 = HttpDate(SystemTime::UNIX_EPOCH + Duration::from_secs(784198117));
+
+        assert_parsed_date!("Mon, 07 Nov 1994 08:48:37 GMT", nov_07);
+        assert_parsed_date!("Monday, 07-Nov-94 08:48:37 GMT", nov_07);
+        assert_parsed_date!("Mon Nov  7 08:48:37 1994", nov_07);
+
+        assert!("this-is-no-date".parse::<HttpDate>().is_err());
+    }
+}

actix-http/src/header/shared/httpdate.rs

@@ -1,97 +0,0 @@
-use std::{
-    fmt,
-    io::Write,
-    str::FromStr,
-    time::{SystemTime, UNIX_EPOCH},
-};
-
-use bytes::buf::BufMut;
-use bytes::BytesMut;
-use http::header::{HeaderValue, InvalidHeaderValue};
-use time::{OffsetDateTime, PrimitiveDateTime, UtcOffset};
-
-use crate::error::ParseError;
-use crate::header::IntoHeaderValue;
-use crate::time_parser;
-
-/// A timestamp with HTTP formatting and parsing.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct HttpDate(OffsetDateTime);
-
-impl FromStr for HttpDate {
-    type Err = ParseError;
-
-    fn from_str(s: &str) -> Result<HttpDate, ParseError> {
-        match time_parser::parse_http_date(s) {
-            Some(t) => Ok(HttpDate(t.assume_utc())),
-            None => Err(ParseError::Header),
-        }
-    }
-}
-
-impl fmt::Display for HttpDate {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.0.format("%a, %d %b %Y %H:%M:%S GMT"), f)
-    }
-}
-
-impl From<SystemTime> for HttpDate {
-    fn from(sys: SystemTime) -> HttpDate {
-        HttpDate(PrimitiveDateTime::from(sys).assume_utc())
-    }
-}
-
-impl IntoHeaderValue for HttpDate {
-    type Error = InvalidHeaderValue;
-
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        let mut wrt = BytesMut::with_capacity(29).writer();
-        write!(
-            wrt,
-            "{}",
-            self.0
-                .to_offset(UtcOffset::UTC)
-                .format("%a, %d %b %Y %H:%M:%S GMT")
-        )
-        .unwrap();
-        HeaderValue::from_maybe_shared(wrt.get_mut().split().freeze())
-    }
-}
-
-impl From<HttpDate> for SystemTime {
-    fn from(date: HttpDate) -> SystemTime {
-        let dt = date.0;
-        let epoch = OffsetDateTime::unix_epoch();
-
-        UNIX_EPOCH + (dt - epoch)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::HttpDate;
-    use time::{date, time, PrimitiveDateTime};
-
-    #[test]
-    fn test_date() {
-        let nov_07 = HttpDate(
-            PrimitiveDateTime::new(date!(1994 - 11 - 07), time!(8:48:37)).assume_utc(),
-        );
-
-        assert_eq!(
-            "Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(),
-            nov_07
-        );
-        assert_eq!(
-            "Sunday, 07-Nov-94 08:48:37 GMT"
-                .parse::<HttpDate>()
-                .unwrap(),
-            nov_07
-        );
-        assert_eq!(
-            "Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(),
-            nov_07
-        );
-        assert!("this-is-no-date".parse::<HttpDate>().is_err());
-    }
-}

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

@@ -3,12 +3,14 @@
 mod charset;
 mod content_encoding;
 mod extended;
-mod httpdate;
+mod http_date;
+mod quality;
 mod quality_item;
 
 pub use self::charset::Charset;
 pub use self::content_encoding::ContentEncoding;
 pub use self::extended::{parse_extended_value, ExtendedValue};
-pub use self::httpdate::HttpDate;
-pub use self::quality_item::{q, qitem, Quality, QualityItem};
+pub use self::http_date::HttpDate;
+pub use self::quality::{q, Quality};
+pub use self::quality_item::QualityItem;
 pub use language_tags::LanguageTag;

actix-http/src/header/shared/quality.rs

@@ -0,0 +1,214 @@
+use std::{
+    convert::{TryFrom, TryInto},
+    fmt,
+};
+
+use derive_more::{Display, Error};
+
+const MAX_QUALITY_INT: u16 = 1000;
+const MAX_QUALITY_FLOAT: f32 = 1.0;
+
+/// Represents a quality used in q-factor values.
+///
+/// The default value is equivalent to `q=1.0` (the [max](Self::MAX) value).
+///
+/// # Implementation notes
+/// The quality value is defined as a number between 0.0 and 1.0 with three decimal places.
+/// This means there are 1001 possible values. Since floating point numbers are not exact and the
+/// smallest floating point data type (`f32`) consumes four bytes, we use an `u16` value to store
+/// the quality internally.
+///
+/// [RFC 7231 §5.3.1] gives more information on quality values in HTTP header fields.
+///
+/// # Examples
+/// ```
+/// use actix_http::header::{Quality, q};
+/// assert_eq!(q(1.0), Quality::MAX);
+///
+/// assert_eq!(q(0.42).to_string(), "0.42");
+/// assert_eq!(q(1.0).to_string(), "1");
+/// assert_eq!(Quality::MIN.to_string(), "0");
+/// ```
+///
+/// [RFC 7231 §5.3.1]: https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.1
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Quality(pub(super) u16);
+
+impl Quality {
+    /// The maximum quality value, equivalent to `q=1.0`.
+    pub const MAX: Quality = Quality(MAX_QUALITY_INT);
+
+    /// The minimum quality value, equivalent to `q=0.0`.
+    pub const MIN: Quality = Quality(0);
+
+    /// Converts a float in the range 0.0–1.0 to a `Quality`.
+    ///
+    /// Intentionally private. External uses should rely on the `TryFrom` impl.
+    ///
+    /// # Panics
+    /// Panics in debug mode when value is not in the range 0.0 <= n <= 1.0.
+    fn from_f32(value: f32) -> Self {
+        // Check that `value` is within range should be done before calling this method.
+        // Just in case, this debug_assert should catch if we were forgetful.
+        debug_assert!(
+            (0.0f32..=1.0f32).contains(&value),
+            "q value must be between 0.0 and 1.0"
+        );
+
+        Quality((value * MAX_QUALITY_INT as f32) as u16)
+    }
+}
+
+/// The default value is [`Quality::MAX`].
+impl Default for Quality {
+    fn default() -> Quality {
+        Quality::MAX
+    }
+}
+
+impl fmt::Display for Quality {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.0 {
+            0 => f.write_str("0"),
+            MAX_QUALITY_INT => f.write_str("1"),
+
+            // some number in the range 1–999
+            x => {
+                f.write_str("0.")?;
+
+                // This implementation avoids string allocation for removing trailing zeroes.
+                // In benchmarks it is twice as fast as approach using something like
+                // `format!("{}").trim_end_matches('0')` for non-fast-path quality values.
+
+                if x < 10 {
+                    // x in is range 1–9
+
+                    f.write_str("00")?;
+
+                    // 0 is already handled so it's not possible to have a trailing 0 in this range
+                    // we can just write the integer
+                    itoa_fmt(f, x)
+                } else if x < 100 {
+                    // x in is range 10–99
+
+                    f.write_str("0")?;
+
+                    if x % 10 == 0 {
+                        // trailing 0, divide by 10 and write
+                        itoa_fmt(f, x / 10)
+                    } else {
+                        itoa_fmt(f, x)
+                    }
+                } else {
+                    // x is in range 100–999
+
+                    if x % 100 == 0 {
+                        // two trailing 0s, divide by 100 and write
+                        itoa_fmt(f, x / 100)
+                    } else if x % 10 == 0 {
+                        // one trailing 0, divide by 10 and write
+                        itoa_fmt(f, x / 10)
+                    } else {
+                        itoa_fmt(f, x)
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Write integer to a `fmt::Write`.
+pub fn itoa_fmt<W: fmt::Write, V: itoa::Integer>(mut wr: W, value: V) -> fmt::Result {
+    let mut buf = itoa::Buffer::new();
+    wr.write_str(buf.format(value))
+}
+
+#[derive(Debug, Clone, Display, Error)]
+#[display(fmt = "quality out of bounds")]
+#[non_exhaustive]
+pub struct QualityOutOfBounds;
+
+impl TryFrom<f32> for Quality {
+    type Error = QualityOutOfBounds;
+
+    #[inline]
+    fn try_from(value: f32) -> Result<Self, Self::Error> {
+        if (0.0..=MAX_QUALITY_FLOAT).contains(&value) {
+            Ok(Quality::from_f32(value))
+        } else {
+            Err(QualityOutOfBounds)
+        }
+    }
+}
+
+/// Convenience function to create a [`Quality`] from an `f32` (0.0–1.0).
+///
+/// Not recommended for use with user input. Rely on the `TryFrom` impls where possible.
+///
+/// # Panics
+/// Panics if value is out of range.
+///
+/// # Examples
+/// ```
+/// # use actix_http::header::{q, Quality};
+/// let q1 = q(1.0);
+/// assert_eq!(q1, Quality::MAX);
+///
+/// let q2 = q(0.0);
+/// assert_eq!(q2, Quality::MIN);
+///
+/// let q3 = q(0.42);
+/// ```
+///
+/// An out-of-range `f32` quality will panic.
+/// ```should_panic
+/// # use actix_http::header::q;
+/// let _q2 = q(1.42);
+/// ```
+#[inline]
+pub fn q<T>(quality: T) -> Quality
+where
+    T: TryInto<Quality>,
+    T::Error: fmt::Debug,
+{
+    quality.try_into().expect("quality value was out of bounds")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn q_helper() {
+        assert_eq!(q(0.5), Quality(500));
+    }
+
+    #[test]
+    fn display_output() {
+        assert_eq!(q(0.0).to_string(), "0");
+        assert_eq!(q(1.0).to_string(), "1");
+        assert_eq!(q(0.001).to_string(), "0.001");
+        assert_eq!(q(0.5).to_string(), "0.5");
+        assert_eq!(q(0.22).to_string(), "0.22");
+        assert_eq!(q(0.123).to_string(), "0.123");
+        assert_eq!(q(0.999).to_string(), "0.999");
+
+        for x in 0..=1000 {
+            // if trailing zeroes are handled correctly, we would not expect the serialized length
+            // to ever exceed "0." + 3 decimal places = 5 in length
+            assert!(q(x as f32 / 1000.0).to_string().len() <= 5);
+        }
+    }
+
+    #[test]
+    #[should_panic]
+    fn negative_quality() {
+        q(-1.0);
+    }
+
+    #[test]
+    #[should_panic]
+    fn quality_out_of_bounds() {
+        q(2.0);
+    }
+}

actix-http/src/header/shared/quality_item.rs

@@ -1,101 +1,65 @@
-use std::{
-    cmp,
-    convert::{TryFrom, TryInto},
-    fmt, str,
-};
+use std::{cmp, convert::TryFrom as _, fmt, str};
 
-use derive_more::{Display, Error};
+use crate::error::ParseError;
 
-const MAX_QUALITY: u16 = 1000;
-const MAX_FLOAT_QUALITY: f32 = 1.0;
+use super::Quality;
 
-/// Represents a quality used in quality values.
+/// Represents an item with a quality value as defined
+/// in [RFC 7231 §5.3.1](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.1).
 ///
-/// Can be created with the [`q`] function.
+/// # Parsing and Formatting
+/// This wrapper be used to parse header value items that have a q-factor annotation as well as
+/// serialize items with a their q-factor.
 ///
-/// # Implementation notes
+/// # Ordering
+/// Since this context of use for this type is header value items, ordering is defined for
+/// `QualityItem`s but _only_ considers the item's quality. Order of appearance should be used as
+/// the secondary sorting parameter; i.e., a stable sort over the quality values will produce a
+/// correctly sorted sequence.
 ///
-/// The quality value is defined as a number between 0 and 1 with three decimal
-/// places. This means there are 1001 possible values. Since floating point
-/// numbers are not exact and the smallest floating point data type (`f32`)
-/// consumes four bytes, hyper uses an `u16` value to store the
-/// quality internally. For performance reasons you may set quality directly to
-/// a value between 0 and 1000 e.g. `Quality(532)` matches the quality
-/// `q=0.532`.
+/// # Examples
+/// ```
+/// # use actix_http::header::{QualityItem, q};
+/// let q_item: QualityItem<String> = "hello;q=0.3".parse().unwrap();
+/// assert_eq!(&q_item.item, "hello");
+/// assert_eq!(q_item.quality, q(0.3));
 ///
-/// [RFC7231 Section 5.3.1](https://tools.ietf.org/html/rfc7231#section-5.3.1)
-/// gives more information on quality values in HTTP header fields.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Quality(u16);
-
-impl Quality {
-    /// # Panics
-    /// Panics in debug mode when value is not in the range 0.0 <= n <= 1.0.
-    fn from_f32(value: f32) -> Self {
-        // Check that `value` is within range should be done before calling this method.
-        // Just in case, this debug_assert should catch if we were forgetful.
-        debug_assert!(
-            (0.0f32..=1.0f32).contains(&value),
-            "q value must be between 0.0 and 1.0"
-        );
-
-        Quality((value * MAX_QUALITY as f32) as u16)
-    }
-}
-
-impl Default for Quality {
-    fn default() -> Quality {
-        Quality(MAX_QUALITY)
-    }
-}
-
-#[derive(Debug, Clone, Display, Error)]
-pub struct QualityOutOfBounds;
-
-impl TryFrom<u16> for Quality {
-    type Error = QualityOutOfBounds;
-
-    fn try_from(value: u16) -> Result<Self, Self::Error> {
-        if (0..=MAX_QUALITY).contains(&value) {
-            Ok(Quality(value))
-        } else {
-            Err(QualityOutOfBounds)
-        }
-    }
-}
-
-impl TryFrom<f32> for Quality {
-    type Error = QualityOutOfBounds;
-
-    fn try_from(value: f32) -> Result<Self, Self::Error> {
-        if (0.0..=MAX_FLOAT_QUALITY).contains(&value) {
-            Ok(Quality::from_f32(value))
-        } else {
-            Err(QualityOutOfBounds)
-        }
-    }
-}
-
-/// Represents an item with a quality value as defined in
-/// [RFC7231](https://tools.ietf.org/html/rfc7231#section-5.3.1).
-#[derive(Clone, PartialEq, Debug)]
+/// // note that format is normalized compared to parsed item
+/// assert_eq!(q_item.to_string(), "hello; q=0.3");
+///
+/// // item with q=0.3 is greater than item with q=0.1
+/// let q_item_fallback: QualityItem<String> = "abc;q=0.1".parse().unwrap();
+/// assert!(q_item > q_item_fallback);
+/// ```
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct QualityItem<T> {
-    /// The actual contents of the field.
+    /// The wrapped contents of the field.
     pub item: T,
+
     /// The quality (client or server preference) for the value.
     pub quality: Quality,
 }
 
 impl<T> QualityItem<T> {
-    /// Creates a new `QualityItem` from an item and a quality.
-    /// The item can be of any type.
-    /// The quality should be a value in the range [0, 1].
-    pub fn new(item: T, quality: Quality) -> QualityItem<T> {
+    /// Constructs a new `QualityItem` from an item and a quality value.
+    ///
+    /// The item can be of any type. The quality should be a value in the range [0, 1].
+    pub fn new(item: T, quality: Quality) -> Self {
         QualityItem { item, quality }
     }
+
+    /// Constructs a new `QualityItem` from an item, using the maximum q-value.
+    pub fn max(item: T) -> Self {
+        Self::new(item, Quality::MAX)
+    }
+
+    /// Constructs a new `QualityItem` from an item, using the minimum q-value.
+    pub fn min(item: T) -> Self {
+        Self::new(item, Quality::MIN)
+    }
 }
 
-impl<T: PartialEq> cmp::PartialOrd for QualityItem<T> {
+impl<T: PartialEq> PartialOrd for QualityItem<T> {
     fn partial_cmp(&self, other: &QualityItem<T>) -> Option<cmp::Ordering> {
         self.quality.partial_cmp(&other.quality)
     }
@@ -105,97 +69,76 @@ impl<T: fmt::Display> fmt::Display for QualityItem<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&self.item, f)?;
 
-        match self.quality.0 {
-            MAX_QUALITY => Ok(()),
-            0 => f.write_str("; q=0"),
-            x => write!(f, "; q=0.{}", format!("{:03}", x).trim_end_matches('0')),
+        match self.quality {
+            // q-factor value is implied for max value
+            Quality::MAX => Ok(()),
+
+            Quality::MIN => f.write_str("; q=0"),
+            q => write!(f, "; q={}", q),
         }
     }
 }
 
 impl<T: str::FromStr> str::FromStr for QualityItem<T> {
-    type Err = crate::error::ParseError;
+    type Err = ParseError;
 
-    fn from_str(qitem_str: &str) -> Result<QualityItem<T>, crate::error::ParseError> {
-        if !qitem_str.is_ascii() {
-            return Err(crate::error::ParseError::Header);
+    fn from_str(q_item_str: &str) -> Result<Self, Self::Err> {
+        if !q_item_str.is_ascii() {
+            return Err(ParseError::Header);
         }
 
-        // Set defaults used if parsing fails.
-        let mut raw_item = qitem_str;
-        let mut quality = 1f32;
+        // set defaults used if quality-item parsing fails, i.e., item has no q attribute
+        let mut raw_item = q_item_str;
+        let mut quality = Quality::MAX;
 
-        let parts: Vec<_> = qitem_str.rsplitn(2, ';').map(str::trim).collect();
+        let parts = q_item_str
+            .rsplit_once(';')
+            .map(|(item, q_attr)| (item.trim(), q_attr.trim()));
 
-        if parts.len() == 2 {
+        if let Some((val, q_attr)) = parts {
             // example for item with q-factor:
             //
-            // gzip; q=0.65
-            //       ^^^^^^  parts[0]
-            //       ^^      start
-            //         ^^^^  q_val
-            // ^^^^          parts[1]
+            // gzip;q=0.65
+            // ^^^^         val
+            //      ^^^^^^  q_attr
+            //      ^^      q
+            //        ^^^^  q_val
 
-            if parts[0].len() < 2 {
+            if q_attr.len() < 2 {
                 // Can't possibly be an attribute since an attribute needs at least a name followed
                 // by an equals sign. And bare identifiers are forbidden.
-                return Err(crate::error::ParseError::Header);
+                return Err(ParseError::Header);
             }
 
-            let start = &parts[0][0..2];
+            let q = &q_attr[0..2];
 
-            if start == "q=" || start == "Q=" {
-                let q_val = &parts[0][2..];
+            if q == "q=" || q == "Q=" {
+                let q_val = &q_attr[2..];
                 if q_val.len() > 5 {
                     // longer than 5 indicates an over-precise q-factor
-                    return Err(crate::error::ParseError::Header);
+                    return Err(ParseError::Header);
                 }
 
-                let q_value = q_val
-                    .parse::<f32>()
-                    .map_err(|_| crate::error::ParseError::Header)?;
+                let q_value = q_val.parse::<f32>().map_err(|_| ParseError::Header)?;
+                let q_value = Quality::try_from(q_value).map_err(|_| ParseError::Header)?;
 
-                if (0f32..=1f32).contains(&q_value) {
-                    quality = q_value;
-                    raw_item = parts[1];
-                } else {
-                    return Err(crate::error::ParseError::Header);
-                }
+                quality = q_value;
+                raw_item = val;
             }
         }
 
-        let item = raw_item
-            .parse::<T>()
-            .map_err(|_| crate::error::ParseError::Header)?;
+        let item = raw_item.parse::<T>().map_err(|_| ParseError::Header)?;
 
-        // we already checked above that the quality is within range
-        Ok(QualityItem::new(item, Quality::from_f32(quality)))
+        Ok(QualityItem::new(item, quality))
     }
 }
 
-/// Convenience function to wrap a value in a `QualityItem`
-/// Sets `q` to the default 1.0
-pub fn qitem<T>(item: T) -> QualityItem<T> {
-    QualityItem::new(item, Quality::default())
-}
-
-/// Convenience function to create a `Quality` from a float or integer.
-///
-/// Implemented for `u16` and `f32`. Panics if value is out of range.
-pub fn q<T>(val: T) -> Quality
-where
-    T: TryInto<Quality>,
-    T::Error: fmt::Debug,
-{
-    // TODO: on next breaking change, handle unwrap differently
-    val.try_into().unwrap()
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
     // copy of encoding from actix-web headers
+    #[allow(clippy::enum_variant_names)] // allow Encoding prefix on EncodingExt
     #[derive(Clone, PartialEq, Debug)]
     pub enum Encoding {
         Chunked,
@@ -244,7 +187,7 @@ mod tests {
     #[test]
     fn test_quality_item_fmt_q_1() {
         use Encoding::*;
-        let x = qitem(Chunked);
+        let x = QualityItem::max(Chunked);
         assert_eq!(format!("{}", x), "chunked");
     }
     #[test]
@@ -343,25 +286,8 @@ mod tests {
     fn test_quality_item_ordering() {
         let x: QualityItem<Encoding> = "gzip; q=0.5".parse().ok().unwrap();
         let y: QualityItem<Encoding> = "gzip; q=0.273".parse().ok().unwrap();
-        let comparision_result: bool = x.gt(&y);
-        assert!(comparision_result)
-    }
-
-    #[test]
-    fn test_quality() {
-        assert_eq!(q(0.5), Quality(500));
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_quality_invalid() {
-        q(-1.0);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_quality_invalid2() {
-        q(2.0);
+        let comparison_result: bool = x.gt(&y);
+        assert!(comparison_result)
     }
 
     #[test]

actix-http/src/header/utils.rs

@@ -1,3 +1,5 @@
+//! Header parsing utilities.
+
 use std::{fmt, str::FromStr};
 
 use super::HeaderValue;
@@ -10,9 +12,12 @@ where
     I: Iterator<Item = &'a HeaderValue> + 'a,
     T: FromStr,
 {
-    let mut result = Vec::new();
+    let size_guess = all.size_hint().1.unwrap_or(2);
+    let mut result = Vec::with_capacity(size_guess);
+
     for h in all {
         let s = h.to_str().map_err(|_| ParseError::Header)?;
+
         result.extend(
             s.split(',')
                 .filter_map(|x| match x.trim() {
@@ -22,6 +27,7 @@ where
                 .filter_map(|x| x.trim().parse().ok()),
         )
     }
+
     Ok(result)
 }
 
@@ -30,10 +36,12 @@ where
 pub fn from_one_raw_str<T: FromStr>(val: Option<&HeaderValue>) -> Result<T, ParseError> {
     if let Some(line) = val {
         let line = line.to_str().map_err(|_| ParseError::Header)?;
+
         if !line.is_empty() {
             return T::from_str(line).or(Err(ParseError::Header));
         }
     }
+
     Err(ParseError::Header)
 }
 
@@ -44,19 +52,53 @@ where
     T: fmt::Display,
 {
     let mut iter = parts.iter();
+
     if let Some(part) = iter.next() {
         fmt::Display::fmt(part, f)?;
     }
+
     for part in iter {
         f.write_str(", ")?;
         fmt::Display::fmt(part, f)?;
     }
+
     Ok(())
 }
 
-/// Percent encode a sequence of bytes with a character set defined in
-/// <https://tools.ietf.org/html/rfc5987#section-3.2>
+/// Percent encode a sequence of bytes with a character set defined in [RFC 5987 §3.2].
+///
+/// [RFC 5987 §3.2]: https://datatracker.ietf.org/doc/html/rfc5987#section-3.2
+#[inline]
 pub fn http_percent_encode(f: &mut fmt::Formatter<'_>, bytes: &[u8]) -> fmt::Result {
     let encoded = percent_encoding::percent_encode(bytes, HTTP_VALUE);
     fmt::Display::fmt(&encoded, f)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn comma_delimited_parsing() {
+        let headers = vec![];
+        let res: Vec<usize> = from_comma_delimited(headers.iter()).unwrap();
+        assert_eq!(res, vec![0; 0]);
+
+        let headers = vec![
+            HeaderValue::from_static("1, 2"),
+            HeaderValue::from_static("3,4"),
+        ];
+        let res: Vec<usize> = from_comma_delimited(headers.iter()).unwrap();
+        assert_eq!(res, vec![1, 2, 3, 4]);
+
+        let headers = vec![
+            HeaderValue::from_static(""),
+            HeaderValue::from_static(","),
+            HeaderValue::from_static("  "),
+            HeaderValue::from_static("1    ,"),
+            HeaderValue::from_static(""),
+        ];
+        let res: Vec<usize> = from_comma_delimited(headers.iter()).unwrap();
+        assert_eq!(res, vec![1]);
+    }
+}

actix-http/src/lib.rs

@@ -1,22 +1,24 @@
 //! HTTP primitives for the Actix ecosystem.
 //!
 //! ## Crate Features
-//! | Feature          | Functionality                                         |
-//! | ---------------- | ----------------------------------------------------- |
-//! | `openssl`        | TLS support via [OpenSSL].                            |
-//! | `rustls`         | TLS support via [rustls].                             |
-//! | `compress`       | Payload compression support. (Deflate, Gzip & Brotli) |
-//! | `trust-dns`      | Use [trust-dns] as the client DNS resolver.           |
+//! | Feature             | Functionality                               |
+//! | ------------------- | ------------------------------------------- |
+//! | `openssl`           | TLS support via [OpenSSL].                  |
+//! | `rustls`            | TLS support via [rustls].                   |
+//! | `compress-brotli`   | Payload compression support: Brotli.        |
+//! | `compress-gzip`     | Payload compression support: Deflate, Gzip. |
+//! | `compress-zstd`     | Payload compression support: Zstd.          |
+//! | `trust-dns`         | Use [trust-dns] as the client DNS resolver. |
 //!
 //! [OpenSSL]: https://crates.io/crates/openssl
 //! [rustls]: https://crates.io/crates/rustls
 //! [trust-dns]: https://crates.io/crates/trust-dns
 
 #![deny(rust_2018_idioms, nonstandard_style)]
+#![warn(future_incompatible)]
 #![allow(
     clippy::type_complexity,
     clippy::too_many_arguments,
-    clippy::new_without_default,
     clippy::borrow_interior_mutable_const
 )]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
@@ -25,30 +27,26 @@
 #[macro_use]
 extern crate log;
 
-#[macro_use]
-mod macros;
+pub use ::http::{uri, uri::Uri};
+pub use ::http::{Method, StatusCode, Version};
 
 pub mod body;
 mod builder;
-pub mod client;
 mod config;
-#[cfg(feature = "compress")]
+#[cfg(feature = "__compress")]
 pub mod encoding;
+pub mod error;
 mod extensions;
+pub mod h1;
+pub mod h2;
 pub mod header;
 mod helpers;
 mod http_message;
 mod message;
 mod payload;
-mod request;
-mod response;
-mod response_builder;
+mod requests;
+mod responses;
 mod service;
-mod time_parser;
-
-pub mod error;
-pub mod h1;
-pub mod h2;
 pub mod test;
 pub mod ws;
 
@@ -59,36 +57,13 @@ pub use self::extensions::Extensions;
 pub use self::header::ContentEncoding;
 pub use self::http_message::HttpMessage;
 pub use self::message::ConnectionType;
-pub use self::message::{Message, RequestHead, RequestHeadType, ResponseHead};
-pub use self::payload::{Payload, PayloadStream};
-pub use self::request::Request;
-pub use self::response::Response;
-pub use self::response_builder::ResponseBuilder;
+pub use self::message::Message;
+#[allow(deprecated)]
+pub use self::payload::{BoxedPayloadStream, Payload, PayloadStream};
+pub use self::requests::{Request, RequestHead, RequestHeadType};
+pub use self::responses::{Response, ResponseBuilder, ResponseHead};
 pub use self::service::HttpService;
 
-pub use ::http::{uri, uri::Uri};
-pub use ::http::{Method, StatusCode, Version};
-
-// TODO: deprecate this mish-mash of random items
-pub mod http {
-    //! Various HTTP related types.
-
-    // re-exports
-    pub use http::header::{HeaderName, HeaderValue};
-    pub use http::uri::PathAndQuery;
-    pub use http::{uri, Error, Uri};
-    pub use http::{Method, StatusCode, Version};
-
-    pub use crate::header::HeaderMap;
-
-    /// A collection of HTTP headers and helpers.
-    pub mod header {
-        pub use crate::header::*;
-    }
-    pub use crate::header::ContentEncoding;
-    pub use crate::message::ConnectionType;
-}
-
 /// A major HTTP protocol version.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 #[non_exhaustive]
@@ -104,34 +79,18 @@ type ConnectCallback<IO> = dyn Fn(&IO, &mut Extensions);
 ///
 /// # Implementation Details
 /// Uses Option to reduce necessary allocations when merging with request extensions.
+#[derive(Default)]
 pub(crate) struct OnConnectData(Option<Extensions>);
 
-impl Default for OnConnectData {
-    fn default() -> Self {
-        Self(None)
-    }
-}
-
 impl OnConnectData {
     /// Construct by calling the on-connect callback with the underlying transport I/O.
-    pub(crate) fn from_io<T>(
-        io: &T,
-        on_connect_ext: Option<&ConnectCallback<T>>,
-    ) -> Self {
+    pub(crate) fn from_io<T>(io: &T, on_connect_ext: Option<&ConnectCallback<T>>) -> Self {
         let ext = on_connect_ext.map(|handler| {
-            let mut extensions = Extensions::new();
+            let mut extensions = Extensions::default();
             handler(io, &mut extensions);
             extensions
         });
 
         Self(ext)
     }
-
-    /// Merge self into given request's extensions.
-    #[inline]
-    pub(crate) fn merge_into(&mut self, req: &mut Request) {
-        if let Some(ref mut ext) = self.0 {
-            req.head.extensions.get_mut().drain_from(ext);
-        }
-    }
 }

actix-http/src/macros.rs

@@ -1,110 +0,0 @@
-#[macro_export]
-#[doc(hidden)]
-macro_rules! downcast_get_type_id {
-    () => {
-        /// A helper method to get the type ID of the type
-        /// this trait is implemented on.
-        /// This method is unsafe to *implement*, since `downcast_ref` relies
-        /// on the returned `TypeId` to perform a cast.
-        ///
-        /// Unfortunately, Rust has no notion of a trait method that is
-        /// unsafe to implement (marking it as `unsafe` makes it unsafe
-        /// to *call*). As a workaround, we require this method
-        /// to return a private type along with the `TypeId`. This
-        /// private type (`PrivateHelper`) has a private constructor,
-        /// making it impossible for safe code to construct outside of
-        /// this module. This ensures that safe code cannot violate
-        /// type-safety by implementing this method.
-        ///
-        /// We also take `PrivateHelper` as a parameter, to ensure that
-        /// safe code cannot obtain a `PrivateHelper` instance by
-        /// delegating to an existing implementation of `__private_get_type_id__`
-        #[doc(hidden)]
-        fn __private_get_type_id__(
-            &self,
-            _: PrivateHelper,
-        ) -> (std::any::TypeId, PrivateHelper)
-        where
-            Self: 'static,
-        {
-            (std::any::TypeId::of::<Self>(), PrivateHelper(()))
-        }
-    };
-}
-
-//Generate implementation for dyn $name
-#[doc(hidden)]
-#[macro_export]
-macro_rules! downcast {
-    ($name:ident) => {
-        /// A struct with a private constructor, for use with
-        /// `__private_get_type_id__`. Its single field is private,
-        /// ensuring that it can only be constructed from this module
-        #[doc(hidden)]
-        pub struct PrivateHelper(());
-
-        impl dyn $name + 'static {
-            /// Downcasts generic body to a specific type.
-            pub fn downcast_ref<T: $name + 'static>(&self) -> Option<&T> {
-                if self.__private_get_type_id__(PrivateHelper(())).0
-                    == std::any::TypeId::of::<T>()
-                {
-                    // SAFETY: external crates cannot override the default
-                    // implementation of `__private_get_type_id__`, since
-                    // it requires returning a private type. We can therefore
-                    // rely on the returned `TypeId`, which ensures that this
-                    // case is correct.
-                    unsafe { Some(&*(self as *const dyn $name as *const T)) }
-                } else {
-                    None
-                }
-            }
-
-            /// Downcasts a generic body to a mutable specific type.
-            pub fn downcast_mut<T: $name + 'static>(&mut self) -> Option<&mut T> {
-                if self.__private_get_type_id__(PrivateHelper(())).0
-                    == std::any::TypeId::of::<T>()
-                {
-                    // SAFETY: external crates cannot override the default
-                    // implementation of `__private_get_type_id__`, since
-                    // it requires returning a private type. We can therefore
-                    // rely on the returned `TypeId`, which ensures that this
-                    // case is correct.
-                    unsafe {
-                        Some(&mut *(self as *const dyn $name as *const T as *mut T))
-                    }
-                } else {
-                    None
-                }
-            }
-        }
-    };
-}
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::upper_case_acronyms)]
-
-    trait MB {
-        downcast_get_type_id!();
-    }
-
-    downcast!(MB);
-
-    impl MB for String {}
-    impl MB for () {}
-
-    #[actix_rt::test]
-    async fn test_any_casting() {
-        let mut body = String::from("hello cast");
-        let resp_body: &mut dyn MB = &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/message.rs

@@ -1,16 +1,7 @@
-use std::{
-    cell::{Ref, RefCell, RefMut},
-    net,
-    rc::Rc,
-};
+use std::{cell::RefCell, ops, rc::Rc};
 
 use bitflags::bitflags;
 
-use crate::{
-    header::{self, HeaderMap},
-    Extensions, Method, StatusCode, Uri, Version,
-};
-
 /// Represents various types of connection
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum ConnectionType {
@@ -44,309 +35,6 @@ pub trait Head: Default + 'static {
         F: FnOnce(&MessagePool<Self>) -> R;
 }
 
-#[derive(Debug)]
-pub struct RequestHead {
-    pub uri: Uri,
-    pub method: Method,
-    pub version: Version,
-    pub headers: HeaderMap,
-    pub extensions: RefCell<Extensions>,
-    pub peer_addr: Option<net::SocketAddr>,
-    flags: Flags,
-}
-
-impl Default for RequestHead {
-    fn default() -> RequestHead {
-        RequestHead {
-            uri: Uri::default(),
-            method: Method::default(),
-            version: Version::HTTP_11,
-            headers: HeaderMap::with_capacity(16),
-            flags: Flags::empty(),
-            peer_addr: None,
-            extensions: RefCell::new(Extensions::new()),
-        }
-    }
-}
-
-impl Head for RequestHead {
-    fn clear(&mut self) {
-        self.flags = Flags::empty();
-        self.headers.clear();
-        self.extensions.get_mut().clear();
-    }
-
-    fn with_pool<F, R>(f: F) -> R
-    where
-        F: FnOnce(&MessagePool<Self>) -> R,
-    {
-        REQUEST_POOL.with(|p| f(p))
-    }
-}
-
-impl RequestHead {
-    /// Message extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
-        self.extensions.borrow()
-    }
-
-    /// Mutable reference to a the message's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.extensions.borrow_mut()
-    }
-
-    /// Read the message headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    /// Mutable reference to the message headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.headers
-    }
-
-    /// Is to uppercase headers with Camel-Case.
-    /// Default is `false`
-    #[inline]
-    pub fn camel_case_headers(&self) -> bool {
-        self.flags.contains(Flags::CAMEL_CASE)
-    }
-
-    /// Set `true` to send headers which are formatted as Camel-Case.
-    #[inline]
-    pub fn set_camel_case_headers(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::CAMEL_CASE);
-        } else {
-            self.flags.remove(Flags::CAMEL_CASE);
-        }
-    }
-
-    #[inline]
-    /// Set connection type of the message
-    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
-        match ctype {
-            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
-            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
-            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
-        }
-    }
-
-    #[inline]
-    /// Connection type
-    pub fn connection_type(&self) -> ConnectionType {
-        if self.flags.contains(Flags::CLOSE) {
-            ConnectionType::Close
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            ConnectionType::KeepAlive
-        } else if self.flags.contains(Flags::UPGRADE) {
-            ConnectionType::Upgrade
-        } else if self.version < Version::HTTP_11 {
-            ConnectionType::Close
-        } else {
-            ConnectionType::KeepAlive
-        }
-    }
-
-    /// Connection upgrade status
-    pub fn upgrade(&self) -> bool {
-        if let Some(hdr) = self.headers().get(header::CONNECTION) {
-            if let Ok(s) = hdr.to_str() {
-                s.to_ascii_lowercase().contains("upgrade")
-            } else {
-                false
-            }
-        } else {
-            false
-        }
-    }
-
-    #[inline]
-    /// Get response body chunking state
-    pub fn chunked(&self) -> bool {
-        !self.flags.contains(Flags::NO_CHUNKING)
-    }
-
-    #[inline]
-    pub fn no_chunking(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::NO_CHUNKING);
-        } else {
-            self.flags.remove(Flags::NO_CHUNKING);
-        }
-    }
-
-    #[inline]
-    /// Request contains `EXPECT` header
-    pub fn expect(&self) -> bool {
-        self.flags.contains(Flags::EXPECT)
-    }
-
-    #[inline]
-    pub(crate) fn set_expect(&mut self) {
-        self.flags.insert(Flags::EXPECT);
-    }
-}
-
-#[derive(Debug)]
-pub enum RequestHeadType {
-    Owned(RequestHead),
-    Rc(Rc<RequestHead>, Option<HeaderMap>),
-}
-
-impl RequestHeadType {
-    pub fn extra_headers(&self) -> Option<&HeaderMap> {
-        match self {
-            RequestHeadType::Owned(_) => None,
-            RequestHeadType::Rc(_, headers) => headers.as_ref(),
-        }
-    }
-}
-
-impl AsRef<RequestHead> for RequestHeadType {
-    fn as_ref(&self) -> &RequestHead {
-        match self {
-            RequestHeadType::Owned(head) => &head,
-            RequestHeadType::Rc(head, _) => head.as_ref(),
-        }
-    }
-}
-
-impl From<RequestHead> for RequestHeadType {
-    fn from(head: RequestHead) -> Self {
-        RequestHeadType::Owned(head)
-    }
-}
-
-#[derive(Debug)]
-pub struct ResponseHead {
-    pub version: Version,
-    pub status: StatusCode,
-    pub headers: HeaderMap,
-    pub reason: Option<&'static str>,
-    pub(crate) extensions: RefCell<Extensions>,
-    flags: Flags,
-}
-
-impl ResponseHead {
-    /// Create new instance of `ResponseHead` type
-    #[inline]
-    pub fn new(status: StatusCode) -> ResponseHead {
-        ResponseHead {
-            status,
-            version: Version::default(),
-            headers: HeaderMap::with_capacity(12),
-            reason: None,
-            flags: Flags::empty(),
-            extensions: RefCell::new(Extensions::new()),
-        }
-    }
-
-    /// Message extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
-        self.extensions.borrow()
-    }
-
-    /// Mutable reference to a the message's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.extensions.borrow_mut()
-    }
-
-    #[inline]
-    /// Read the message headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    #[inline]
-    /// Mutable reference to the message headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.headers
-    }
-
-    #[inline]
-    /// Set connection type of the message
-    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
-        match ctype {
-            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
-            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
-            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
-        }
-    }
-
-    #[inline]
-    pub fn connection_type(&self) -> ConnectionType {
-        if self.flags.contains(Flags::CLOSE) {
-            ConnectionType::Close
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            ConnectionType::KeepAlive
-        } else if self.flags.contains(Flags::UPGRADE) {
-            ConnectionType::Upgrade
-        } else if self.version < Version::HTTP_11 {
-            ConnectionType::Close
-        } else {
-            ConnectionType::KeepAlive
-        }
-    }
-
-    /// Check if keep-alive is enabled
-    #[inline]
-    pub fn keep_alive(&self) -> bool {
-        self.connection_type() == ConnectionType::KeepAlive
-    }
-
-    /// Check upgrade status of this message
-    #[inline]
-    pub fn upgrade(&self) -> bool {
-        self.connection_type() == ConnectionType::Upgrade
-    }
-
-    /// Get custom reason for the response
-    #[inline]
-    pub fn reason(&self) -> &str {
-        if let Some(reason) = self.reason {
-            reason
-        } else {
-            self.status
-                .canonical_reason()
-                .unwrap_or("<unknown status code>")
-        }
-    }
-
-    #[inline]
-    pub(crate) fn ctype(&self) -> Option<ConnectionType> {
-        if self.flags.contains(Flags::CLOSE) {
-            Some(ConnectionType::Close)
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            Some(ConnectionType::KeepAlive)
-        } else if self.flags.contains(Flags::UPGRADE) {
-            Some(ConnectionType::Upgrade)
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    /// Get response body chunking state
-    pub fn chunked(&self) -> bool {
-        !self.flags.contains(Flags::NO_CHUNKING)
-    }
-
-    #[inline]
-    /// Set no chunking for payload
-    pub fn no_chunking(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::NO_CHUNKING);
-        } else {
-            self.flags.remove(Flags::NO_CHUNKING);
-        }
-    }
-}
-
 pub struct Message<T: Head> {
     /// Rc here should not be cloned by anyone.
     /// It's used to reuse allocation of T and no shared ownership is allowed.
@@ -355,20 +43,21 @@ pub struct Message<T: Head> {
 
 impl<T: Head> Message<T> {
     /// Get new message from the pool of objects
+    #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
-        T::with_pool(|p| p.get_message())
+        T::with_pool(MessagePool::get_message)
     }
 }
 
-impl<T: Head> std::ops::Deref for Message<T> {
+impl<T: Head> ops::Deref for Message<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        &self.head.as_ref()
+        self.head.as_ref()
     }
 }
 
-impl<T: Head> std::ops::DerefMut for Message<T> {
+impl<T: Head> ops::DerefMut for Message<T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         Rc::get_mut(&mut self.head).expect("Multiple copies exist")
     }
@@ -380,53 +69,12 @@ impl<T: Head> Drop for Message<T> {
     }
 }
 
-pub(crate) struct BoxedResponseHead {
-    head: Option<Box<ResponseHead>>,
-}
-
-impl BoxedResponseHead {
-    /// Get new message from the pool of objects
-    pub fn new(status: StatusCode) -> Self {
-        RESPONSE_POOL.with(|p| p.get_message(status))
-    }
-}
-
-impl std::ops::Deref for BoxedResponseHead {
-    type Target = ResponseHead;
-
-    fn deref(&self) -> &Self::Target {
-        self.head.as_ref().unwrap()
-    }
-}
-
-impl std::ops::DerefMut for BoxedResponseHead {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.head.as_mut().unwrap()
-    }
-}
-
-impl Drop for BoxedResponseHead {
-    fn drop(&mut self) {
-        if let Some(head) = self.head.take() {
-            RESPONSE_POOL.with(move |p| p.release(head))
-        }
-    }
-}
-
 #[doc(hidden)]
 /// Request's objects pool
 pub struct MessagePool<T: Head>(RefCell<Vec<Rc<T>>>);
 
-#[doc(hidden)]
-#[allow(clippy::vec_box)]
-/// Request's objects pool
-pub struct BoxedResponsePool(RefCell<Vec<Box<ResponseHead>>>);
-
-thread_local!(static REQUEST_POOL: MessagePool<RequestHead> = MessagePool::<RequestHead>::create());
-thread_local!(static RESPONSE_POOL: BoxedResponsePool = BoxedResponsePool::create());
-
 impl<T: Head> MessagePool<T> {
-    fn create() -> MessagePool<T> {
+    pub(crate) fn create() -> MessagePool<T> {
         MessagePool(RefCell::new(Vec::with_capacity(128)))
     }
 
@@ -448,43 +96,11 @@ impl<T: Head> MessagePool<T> {
     }
 
     #[inline]
-    /// Release request instance
+    /// Release message instance
     fn release(&self, msg: Rc<T>) {
-        let v = &mut self.0.borrow_mut();
-        if v.len() < 128 {
-            v.push(msg);
-        }
-    }
-}
-
-impl BoxedResponsePool {
-    fn create() -> BoxedResponsePool {
-        BoxedResponsePool(RefCell::new(Vec::with_capacity(128)))
-    }
-
-    /// Get message from the pool
-    #[inline]
-    fn get_message(&self, status: StatusCode) -> BoxedResponseHead {
-        if let Some(mut head) = self.0.borrow_mut().pop() {
-            head.reason = None;
-            head.status = status;
-            head.headers.clear();
-            head.flags = Flags::empty();
-            BoxedResponseHead { head: Some(head) }
-        } else {
-            BoxedResponseHead {
-                head: Some(Box::new(ResponseHead::new(status))),
-            }
-        }
-    }
-
-    #[inline]
-    /// Release request instance
-    fn release(&self, mut msg: Box<ResponseHead>) {
-        let v = &mut self.0.borrow_mut();
-        if v.len() < 128 {
-            msg.extensions.get_mut().clear();
-            v.push(msg);
+        let pool = &mut self.0.borrow_mut();
+        if pool.len() < 128 {
+            pool.push(msg);
         }
     }
 }

actix-http/src/payload.rs

@@ -1,70 +1,89 @@
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::{
+    mem,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use bytes::Bytes;
 use futures_core::Stream;
-use h2::RecvStream;
 
 use crate::error::PayloadError;
 
-/// Type represent boxed payload
-pub type PayloadStream = Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>>>>;
+/// A boxed payload stream.
+pub type BoxedPayloadStream = Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>>>>;
 
-/// Type represent streaming payload
-pub enum Payload<S = PayloadStream> {
-    None,
-    H1(crate::h1::Payload),
-    H2(crate::h2::Payload),
-    Stream(S),
+#[deprecated(since = "4.0.0", note = "Renamed to `BoxedPayloadStream`.")]
+pub type PayloadStream = BoxedPayloadStream;
+
+pin_project_lite::pin_project! {
+    /// A streaming payload.
+    #[project = PayloadProj]
+    pub enum Payload<S = BoxedPayloadStream> {
+        None,
+        H1 { payload: crate::h1::Payload },
+        H2 { payload: crate::h2::Payload },
+        Stream { #[pin] payload: S },
+    }
 }
 
 impl<S> From<crate::h1::Payload> for Payload<S> {
-    fn from(v: crate::h1::Payload) -> Self {
-        Payload::H1(v)
+    fn from(payload: crate::h1::Payload) -> Self {
+        Payload::H1 { payload }
     }
 }
 
 impl<S> From<crate::h2::Payload> for Payload<S> {
-    fn from(v: crate::h2::Payload) -> Self {
-        Payload::H2(v)
+    fn from(payload: crate::h2::Payload) -> Self {
+        Payload::H2 { payload }
     }
 }
 
-impl<S> From<RecvStream> for Payload<S> {
-    fn from(v: RecvStream) -> Self {
-        Payload::H2(crate::h2::Payload::new(v))
+impl<S> From<h2::RecvStream> for Payload<S> {
+    fn from(stream: h2::RecvStream) -> Self {
+        Payload::H2 {
+            payload: crate::h2::Payload::new(stream),
+        }
     }
 }
 
-impl From<PayloadStream> for Payload {
-    fn from(pl: PayloadStream) -> Self {
-        Payload::Stream(pl)
+impl From<BoxedPayloadStream> for Payload {
+    fn from(payload: BoxedPayloadStream) -> Self {
+        Payload::Stream { payload }
     }
 }
 
 impl<S> Payload<S> {
     /// Takes current payload and replaces it with `None` value
     pub fn take(&mut self) -> Payload<S> {
-        std::mem::replace(self, Payload::None)
+        mem::replace(self, Payload::None)
     }
 }
 
 impl<S> Stream for Payload<S>
 where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
+    S: Stream<Item = Result<Bytes, PayloadError>>,
 {
     type Item = Result<Bytes, PayloadError>;
 
     #[inline]
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        match self.get_mut() {
-            Payload::None => Poll::Ready(None),
-            Payload::H1(ref mut pl) => pl.readany(cx),
-            Payload::H2(ref mut pl) => Pin::new(pl).poll_next(cx),
-            Payload::Stream(ref mut pl) => Pin::new(pl).poll_next(cx),
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        match self.project() {
+            PayloadProj::None => Poll::Ready(None),
+            PayloadProj::H1 { payload } => Pin::new(payload).poll_next(cx),
+            PayloadProj::H2 { payload } => Pin::new(payload).poll_next(cx),
+            PayloadProj::Stream { payload } => payload.poll_next(cx),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
+    use static_assertions::{assert_impl_all, assert_not_impl_any};
+
+    use super::*;
+
+    assert_impl_all!(Payload: Unpin);
+    assert_not_impl_any!(Payload: Send, Sync, UnwindSafe, RefUnwindSafe);
+}

actix-http/src/requests/head.rs

@@ -0,0 +1,174 @@
+use std::{net, rc::Rc};
+
+use crate::{
+    header::{self, HeaderMap},
+    message::{Flags, Head, MessagePool},
+    ConnectionType, Method, Uri, Version,
+};
+
+thread_local! {
+    static REQUEST_POOL: MessagePool<RequestHead> = MessagePool::<RequestHead>::create()
+}
+
+#[derive(Debug, Clone)]
+pub struct RequestHead {
+    pub method: Method,
+    pub uri: Uri,
+    pub version: Version,
+    pub headers: HeaderMap,
+    pub peer_addr: Option<net::SocketAddr>,
+    flags: Flags,
+}
+
+impl Default for RequestHead {
+    fn default() -> RequestHead {
+        RequestHead {
+            method: Method::default(),
+            uri: Uri::default(),
+            version: Version::HTTP_11,
+            headers: HeaderMap::with_capacity(16),
+            peer_addr: None,
+            flags: Flags::empty(),
+        }
+    }
+}
+
+impl Head for RequestHead {
+    fn clear(&mut self) {
+        self.flags = Flags::empty();
+        self.headers.clear();
+    }
+
+    fn with_pool<F, R>(f: F) -> R
+    where
+        F: FnOnce(&MessagePool<Self>) -> R,
+    {
+        REQUEST_POOL.with(|p| f(p))
+    }
+}
+
+impl RequestHead {
+    /// Read the message headers.
+    pub fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+
+    /// Mutable reference to the message headers.
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        &mut self.headers
+    }
+
+    /// Is to uppercase headers with Camel-Case.
+    /// Default is `false`
+    #[inline]
+    pub fn camel_case_headers(&self) -> bool {
+        self.flags.contains(Flags::CAMEL_CASE)
+    }
+
+    /// Set `true` to send headers which are formatted as Camel-Case.
+    #[inline]
+    pub fn set_camel_case_headers(&mut self, val: bool) {
+        if val {
+            self.flags.insert(Flags::CAMEL_CASE);
+        } else {
+            self.flags.remove(Flags::CAMEL_CASE);
+        }
+    }
+
+    #[inline]
+    /// Set connection type of the message
+    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
+        match ctype {
+            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
+            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
+            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
+        }
+    }
+
+    #[inline]
+    /// Connection type
+    pub fn connection_type(&self) -> ConnectionType {
+        if self.flags.contains(Flags::CLOSE) {
+            ConnectionType::Close
+        } else if self.flags.contains(Flags::KEEP_ALIVE) {
+            ConnectionType::KeepAlive
+        } else if self.flags.contains(Flags::UPGRADE) {
+            ConnectionType::Upgrade
+        } else if self.version < Version::HTTP_11 {
+            ConnectionType::Close
+        } else {
+            ConnectionType::KeepAlive
+        }
+    }
+
+    /// Connection upgrade status
+    pub fn upgrade(&self) -> bool {
+        self.headers()
+            .get(header::CONNECTION)
+            .map(|hdr| {
+                if let Ok(s) = hdr.to_str() {
+                    s.to_ascii_lowercase().contains("upgrade")
+                } else {
+                    false
+                }
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    /// Get response body chunking state
+    pub fn chunked(&self) -> bool {
+        !self.flags.contains(Flags::NO_CHUNKING)
+    }
+
+    #[inline]
+    pub fn no_chunking(&mut self, val: bool) {
+        if val {
+            self.flags.insert(Flags::NO_CHUNKING);
+        } else {
+            self.flags.remove(Flags::NO_CHUNKING);
+        }
+    }
+
+    #[inline]
+    /// Request contains `EXPECT` header
+    pub fn expect(&self) -> bool {
+        self.flags.contains(Flags::EXPECT)
+    }
+
+    #[inline]
+    pub(crate) fn set_expect(&mut self) {
+        self.flags.insert(Flags::EXPECT);
+    }
+}
+
+#[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum RequestHeadType {
+    Owned(RequestHead),
+    Rc(Rc<RequestHead>, Option<HeaderMap>),
+}
+
+impl RequestHeadType {
+    pub fn extra_headers(&self) -> Option<&HeaderMap> {
+        match self {
+            RequestHeadType::Owned(_) => None,
+            RequestHeadType::Rc(_, headers) => headers.as_ref(),
+        }
+    }
+}
+
+impl AsRef<RequestHead> for RequestHeadType {
+    fn as_ref(&self) -> &RequestHead {
+        match self {
+            RequestHeadType::Owned(head) => head,
+            RequestHeadType::Rc(head, _) => head.as_ref(),
+        }
+    }
+}
+
+impl From<RequestHead> for RequestHeadType {
+    fn from(head: RequestHead) -> Self {
+        RequestHeadType::Owned(head)
+    }
+}

actix-http/src/requests/mod.rs

@@ -0,0 +1,7 @@
+//! HTTP requests.
+
+mod head;
+mod request;
+
+pub use self::head::{RequestHead, RequestHeadType};
+pub use self::request::Request;

actix-http/src/requests/request.rs

@@ -1,24 +1,25 @@
 //! HTTP requests.
 
 use std::{
-    cell::{Ref, RefMut},
-    fmt, net, str,
+    cell::{Ref, RefCell, RefMut},
+    fmt, mem, net,
+    rc::Rc,
+    str,
 };
 
 use http::{header, Method, Uri, Version};
 
 use crate::{
-    extensions::Extensions,
-    header::HeaderMap,
-    message::{Message, RequestHead},
-    payload::{Payload, PayloadStream},
-    HttpMessage,
+    header::HeaderMap, BoxedPayloadStream, Extensions, HttpMessage, Message, Payload,
+    RequestHead,
 };
 
-/// Request
-pub struct Request<P = PayloadStream> {
+/// An HTTP request.
+pub struct Request<P = BoxedPayloadStream> {
     pub(crate) payload: Payload<P>,
     pub(crate) head: Message<RequestHead>,
+    pub(crate) conn_data: Option<Rc<Extensions>>,
+    pub(crate) req_data: RefCell<Extensions>,
 }
 
 impl<P> HttpMessage for Request<P> {
@@ -30,37 +31,42 @@ impl<P> HttpMessage for Request<P> {
     }
 
     fn take_payload(&mut self) -> Payload<P> {
-        std::mem::replace(&mut self.payload, Payload::None)
+        mem::replace(&mut self.payload, Payload::None)
     }
 
     /// Request extensions
     #[inline]
     fn extensions(&self) -> Ref<'_, Extensions> {
-        self.head.extensions()
+        self.req_data.borrow()
     }
 
     /// Mutable reference to a the request's extensions
     #[inline]
     fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.head.extensions_mut()
+        self.req_data.borrow_mut()
     }
 }
 
-impl From<Message<RequestHead>> for Request<PayloadStream> {
+impl From<Message<RequestHead>> for Request<BoxedPayloadStream> {
     fn from(head: Message<RequestHead>) -> Self {
         Request {
             head,
             payload: Payload::None,
+            req_data: RefCell::new(Extensions::default()),
+            conn_data: None,
         }
     }
 }
 
-impl Request<PayloadStream> {
+impl Request<BoxedPayloadStream> {
     /// Create new Request instance
-    pub fn new() -> Request<PayloadStream> {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Request<BoxedPayloadStream> {
         Request {
             head: Message::new(),
             payload: Payload::None,
+            req_data: RefCell::new(Extensions::default()),
+            conn_data: None,
         }
     }
 }
@@ -71,16 +77,21 @@ impl<P> Request<P> {
         Request {
             payload,
             head: Message::new(),
+            req_data: RefCell::new(Extensions::default()),
+            conn_data: None,
         }
     }
 
     /// Create new Request instance
     pub fn replace_payload<P1>(self, payload: Payload<P1>) -> (Request<P1>, Payload<P>) {
         let pl = self.payload;
+
         (
             Request {
                 payload,
                 head: self.head,
+                req_data: self.req_data,
+                conn_data: self.conn_data,
             },
             pl,
         )
@@ -93,7 +104,7 @@ impl<P> Request<P> {
 
     /// Get request's payload
     pub fn take_payload(&mut self) -> Payload<P> {
-        std::mem::replace(&mut self.payload, Payload::None)
+        mem::replace(&mut self.payload, Payload::None)
     }
 
     /// Split request into request head and payload
@@ -116,7 +127,7 @@ impl<P> Request<P> {
 
     /// Mutable reference to the message's headers.
     pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.head_mut().headers
+        &mut self.head.headers
     }
 
     /// Request's uri.
@@ -128,7 +139,7 @@ impl<P> Request<P> {
     /// Mutable reference to the request's uri.
     #[inline]
     pub fn uri_mut(&mut self) -> &mut Uri {
-        &mut self.head_mut().uri
+        &mut self.head.uri
     }
 
     /// Read the Request method.
@@ -170,6 +181,31 @@ impl<P> Request<P> {
     pub fn peer_addr(&self) -> Option<net::SocketAddr> {
         self.head().peer_addr
     }
+
+    /// Returns a reference a piece of connection data set in an [on-connect] callback.
+    ///
+    /// ```ignore
+    /// let opt_t = req.conn_data::<PeerCertificate>();
+    /// ```
+    ///
+    /// [on-connect]: crate::HttpServiceBuilder::on_connect_ext
+    pub fn conn_data<T: 'static>(&self) -> Option<&T> {
+        self.conn_data
+            .as_deref()
+            .and_then(|container| container.get::<T>())
+    }
+
+    /// Returns the connection data container if an [on-connect] callback was registered.
+    ///
+    /// [on-connect]: crate::HttpServiceBuilder::on_connect_ext
+    pub fn take_conn_data(&mut self) -> Option<Rc<Extensions>> {
+        self.conn_data.take()
+    }
+
+    /// Returns the request data container, leaving an empty one in it's place.
+    pub fn take_req_data(&mut self) -> Extensions {
+        mem::take(self.req_data.get_mut())
+    }
 }
 
 impl<P> fmt::Debug for Request<P> {

actix-http/src/responses/builder.rs

@@ -2,23 +2,15 @@
 
 use std::{
     cell::{Ref, RefMut},
-    error::Error as StdError,
-    fmt,
-    future::Future,
-    pin::Pin,
-    str,
-    task::{Context, Poll},
+    fmt, str,
 };
 
-use bytes::Bytes;
-use futures_core::Stream;
-
 use crate::{
-    body::{AnyBody, BodyStream},
+    body::{EitherBody, MessageBody},
     error::{Error, HttpError},
-    header::{self, IntoHeaderPair, IntoHeaderValue},
-    message::{BoxedResponseHead, ConnectionType, ResponseHead},
-    Extensions, Response, StatusCode,
+    header::{self, TryIntoHeaderPair, TryIntoHeaderValue},
+    responses::{BoxedResponseHead, ResponseHead},
+    ConnectionType, Extensions, Response, StatusCode,
 };
 
 /// An HTTP response builder.
@@ -28,7 +20,7 @@ use crate::{
 ///
 /// # Examples
 /// ```
-/// use actix_http::{Response, ResponseBuilder, body, http::StatusCode, http::header};
+/// use actix_http::{Response, ResponseBuilder, StatusCode, body, header};
 ///
 /// # actix_rt::System::new().block_on(async {
 /// let mut res: Response<_> = Response::build(StatusCode::OK)
@@ -56,8 +48,7 @@ impl ResponseBuilder {
     ///
     /// # Examples
     /// ```
-    /// use actix_http::{Response, ResponseBuilder, http::StatusCode};
-    ///
+    /// use actix_http::{Response, ResponseBuilder, StatusCode};
     /// let res: Response<_> = ResponseBuilder::default().finish();
     /// assert_eq!(res.status(), StatusCode::OK);
     /// ```
@@ -73,8 +64,7 @@ impl ResponseBuilder {
     ///
     /// # Examples
     /// ```
-    /// use actix_http::{ResponseBuilder, http::StatusCode};
-    ///
+    /// use actix_http::{ResponseBuilder, StatusCode};
     /// let res = ResponseBuilder::default().status(StatusCode::NOT_FOUND).finish();
     /// assert_eq!(res.status(), StatusCode::NOT_FOUND);
     /// ```
@@ -90,7 +80,7 @@ impl ResponseBuilder {
     ///
     /// # Examples
     /// ```
-    /// use actix_http::{ResponseBuilder, http::header};
+    /// use actix_http::{ResponseBuilder, header};
     ///
     /// let res = ResponseBuilder::default()
     ///     .insert_header((header::CONTENT_TYPE, mime::APPLICATION_JSON))
@@ -100,12 +90,9 @@ impl ResponseBuilder {
     /// assert!(res.headers().contains_key("content-type"));
     /// assert!(res.headers().contains_key("x-test"));
     /// ```
-    pub fn insert_header<H>(&mut self, header: H) -> &mut Self
-    where
-        H: IntoHeaderPair,
-    {
+    pub fn insert_header(&mut self, header: impl TryIntoHeaderPair) -> &mut Self {
         if let Some(parts) = self.inner() {
-            match header.try_into_header_pair() {
+            match header.try_into_pair() {
                 Ok((key, value)) => {
                     parts.headers.insert(key, value);
                 }
@@ -120,7 +107,7 @@ impl ResponseBuilder {
     ///
     /// # Examples
     /// ```
-    /// use actix_http::{ResponseBuilder, http::header};
+    /// use actix_http::{ResponseBuilder, header};
     ///
     /// let res = ResponseBuilder::default()
     ///     .append_header((header::CONTENT_TYPE, mime::APPLICATION_JSON))
@@ -131,12 +118,9 @@ impl ResponseBuilder {
     /// assert_eq!(res.headers().get_all("content-type").count(), 1);
     /// assert_eq!(res.headers().get_all("x-test").count(), 2);
     /// ```
-    pub fn append_header<H>(&mut self, header: H) -> &mut Self
-    where
-        H: IntoHeaderPair,
-    {
+    pub fn append_header(&mut self, header: impl TryIntoHeaderPair) -> &mut Self {
         if let Some(parts) = self.inner() {
-            match header.try_into_header_pair() {
+            match header.try_into_pair() {
                 Ok((key, value)) => parts.headers.append(key, value),
                 Err(e) => self.err = Some(e.into()),
             };
@@ -167,7 +151,7 @@ impl ResponseBuilder {
     #[inline]
     pub fn upgrade<V>(&mut self, value: V) -> &mut Self
     where
-        V: IntoHeaderValue,
+        V: TryIntoHeaderValue,
     {
         if let Some(parts) = self.inner() {
             parts.set_connection_type(ConnectionType::Upgrade);
@@ -205,7 +189,7 @@ impl ResponseBuilder {
     #[inline]
     pub fn content_type<V>(&mut self, value: V) -> &mut Self
     where
-        V: IntoHeaderValue,
+        V: TryIntoHeaderValue,
     {
         if let Some(parts) = self.inner() {
             match value.try_into_value() {
@@ -235,10 +219,14 @@ impl ResponseBuilder {
     /// Generate response with a wrapped body.
     ///
     /// This `ResponseBuilder` will be left in a useless state.
-    #[inline]
-    pub fn body<B: Into<AnyBody>>(&mut self, body: B) -> Response<AnyBody> {
-        self.message_body(body.into())
-            .unwrap_or_else(Response::from)
+    pub fn body<B>(&mut self, body: B) -> Response<EitherBody<B>>
+    where
+        B: MessageBody + 'static,
+    {
+        match self.message_body(body) {
+            Ok(res) => res.map_body(|_, body| EitherBody::left(body)),
+            Err(err) => Response::from(err).map_body(|_, body| EitherBody::right(body)),
+        }
     }
 
     /// Generate response with a body.
@@ -253,24 +241,12 @@ impl ResponseBuilder {
         Ok(Response { head, body })
     }
 
-    /// Generate response with a streaming body.
-    ///
-    /// This `ResponseBuilder` will be left in a useless state.
-    #[inline]
-    pub fn streaming<S, E>(&mut self, stream: S) -> Response<AnyBody>
-    where
-        S: Stream<Item = Result<Bytes, E>> + 'static,
-        E: Into<Box<dyn StdError>> + 'static,
-    {
-        self.body(AnyBody::from_message(BodyStream::new(stream)))
-    }
-
     /// Generate response with an empty body.
     ///
     /// This `ResponseBuilder` will be left in a useless state.
     #[inline]
-    pub fn finish(&mut self) -> Response<AnyBody> {
-        self.body(AnyBody::Empty)
+    pub fn finish(&mut self) -> Response<EitherBody<()>> {
+        self.body(())
     }
 
     /// Create an owned `ResponseBuilder`, leaving the original in a useless state.
@@ -327,14 +303,6 @@ impl<'a> From<&'a ResponseHead> for ResponseBuilder {
     }
 }
 
-impl Future for ResponseBuilder {
-    type Output = Result<Response<AnyBody>, Error>;
-
-    fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
-        Poll::Ready(Ok(self.finish()))
-    }
-}
-
 impl fmt::Debug for ResponseBuilder {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let head = self.head.as_ref().unwrap();
@@ -356,9 +324,10 @@ impl fmt::Debug for ResponseBuilder {
 
 #[cfg(test)]
 mod tests {
+    use bytes::Bytes;
+
     use super::*;
-    use crate::body::Body;
-    use crate::http::header::{HeaderName, HeaderValue, CONTENT_TYPE};
+    use crate::header::{HeaderName, HeaderValue, CONTENT_TYPE};
 
     #[test]
     fn test_basic_builder() {
@@ -383,20 +352,28 @@ mod tests {
     #[test]
     fn test_force_close() {
         let resp = Response::build(StatusCode::OK).force_close().finish();
-        assert!(!resp.keep_alive())
+        assert!(!resp.keep_alive());
     }
 
     #[test]
     fn test_content_type() {
         let resp = Response::build(StatusCode::OK)
             .content_type("text/plain")
-            .body(Body::Empty);
-        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "text/plain")
+            .body(Bytes::new());
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "text/plain");
+
+        let resp = Response::build(StatusCode::OK)
+            .content_type(mime::APPLICATION_JAVASCRIPT_UTF_8)
+            .body(Bytes::new());
+        assert_eq!(
+            resp.headers().get(CONTENT_TYPE).unwrap(),
+            "application/javascript; charset=utf-8"
+        );
     }
 
     #[test]
     fn test_into_builder() {
-        let mut resp: Response<Body> = "test".into();
+        let mut resp: Response<_> = "test".into();
         assert_eq!(resp.status(), StatusCode::OK);
 
         resp.headers_mut().insert(