Merge branch 'master' into logger-custom-response-replace

.github/workflows/ci-post-merge.yml

@@ -23,6 +23,7 @@ jobs:
       CI: 1
       CARGO_INCREMENTAL: 0
       VCPKGRS_DYNAMIC: 1
+      CARGO_UNSTABLE_SPARSE_REGISTRY: true
 
     steps:
       - uses: actions/checkout@v2
@@ -44,18 +45,15 @@ jobs:
           profile: minimal
           override: true
 
+      - name: Install cargo-hack
+        uses: taiki-e/install-action@cargo-hack
+
       - 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 minimal
         uses: actions-rs/cargo@v1
         with: { command: ci-check-min }
@@ -80,12 +78,17 @@ jobs:
 
       - name: Clear the cargo caches
         run: |
-          cargo install cargo-cache --version 0.6.3 --no-default-features --features ci-autoclean
+          cargo install cargo-cache --version 0.8.2 --no-default-features --features ci-autoclean
           cargo-cache
 
   ci_feature_powerset_check:
     name: Verify Feature Combinations
     runs-on: ubuntu-latest
+
+    env:
+      CI: 1
+      CARGO_INCREMENTAL: 0
+
     steps:
       - uses: actions/checkout@v2
 
@@ -96,18 +99,15 @@ jobs:
           profile: minimal
           override: true
 
+      - name: Install cargo-hack
+        uses: taiki-e/install-action@cargo-hack
+
       - 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 }
@@ -119,6 +119,11 @@ jobs:
   nextest:
     name: nextest
     runs-on: ubuntu-latest
+
+    env:
+      CI: 1
+      CARGO_INCREMENTAL: 0
+
     steps:
       - uses: actions/checkout@v2
 
@@ -129,18 +134,15 @@ jobs:
           profile: minimal
           override: true
 
+      - name: Install nextest
+        uses: taiki-e/install-action@nextest
+
       - name: Generate Cargo.lock
         uses: actions-rs/cargo@v1
         with: { command: generate-lockfile }
       - name: Cache Dependencies
         uses: Swatinem/rust-cache@v1.3.0
 
-      - name: Install cargo-nextest
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-nextest
-
       - name: Test with cargo-nextest
         uses: actions-rs/cargo@v1
         with:

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
           - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin }
           - { name: Windows, os: windows-2022, triple: x86_64-pc-windows-msvc }
         version:
-          - 1.54.0 # MSRV
+          - 1.59.0 # MSRV
           - stable
 
     name: ${{ matrix.target.name }} / ${{ matrix.version }}
@@ -47,18 +47,22 @@ jobs:
           profile: minimal
           override: true
 
+      - name: Install cargo-hack
+        uses: taiki-e/install-action@cargo-hack
+
+      - name: workaround MSRV issues
+        if: matrix.version != 'stable'
+        run: |
+          cargo install cargo-edit --version=0.8.0
+          cargo add const-str@0.3 --dev -p=actix-web
+          cargo add const-str@0.3 --dev -p=awc
+
       - 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 minimal
         uses: actions-rs/cargo@v1
         with: { command: ci-check-min }
@@ -83,7 +87,7 @@ jobs:
 
       - name: Clear the cargo caches
         run: |
-          cargo install cargo-cache --version 0.6.3 --no-default-features --features ci-autoclean
+          cargo install cargo-cache --version 0.8.2 --no-default-features --features ci-autoclean
           cargo-cache
 
   io-uring:

.github/workflows/upload-doc.yml

@@ -28,8 +28,7 @@ jobs:
         run: echo '<meta http-equiv="refresh" content="0;url=actix_web/index.html">' > target/doc/index.html
 
       - name: Deploy to GitHub Pages
-        uses: JamesIves/github-pages-deploy-action@3.7.1
+        uses: JamesIves/github-pages-deploy-action@v4.4.0
         with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          folder: target/doc
-          BRANCH: gh-pages
+          single-commit: true
-          FOLDER: target/doc

actix-files/CHANGES.md

@@ -1,9 +1,21 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.
+
+
+## 0.6.2 - 2022-07-23
+- Allow partial range responses for video content to start streaming sooner. [#2817]
+- Minimum supported Rust version (MSRV) is now 1.57 due to transitive `time` dependency.
+
+[#2817]: https://github.com/actix/actix-web/pull/2817
+
+
+## 0.6.1 - 2022-06-11
 - Add `NamedFile::{modified, metadata, content_type, content_disposition, encoding}()` getters. [#2021]
 - Update `tokio-uring` dependency to `0.3`.
 - Audio files now use `Content-Disposition: inline` instead of `attachment`. [#2645]
+- Minimum supported Rust version (MSRV) is now 1.56 due to transitive `hashbrown` dependency.
 
 [#2021]: https://github.com/actix/actix-web/pull/2021
 [#2645]: https://github.com/actix/actix-web/pull/2645

actix-files/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.6.0"
+version = "0.6.2"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "fakeshadow <24548779@qq.com>",
@@ -27,7 +27,6 @@ actix-service = "2"
 actix-utils = "3"
 actix-web = { version = "4", default-features = false }
 
-askama_escape = "0.10"
 bitflags = "1"
 bytes = "1"
 derive_more = "0.99.5"
@@ -38,13 +37,15 @@ mime = "0.3"
 mime_guess = "2.0.1"
 percent-encoding = "2.1"
 pin-project-lite = "0.2.7"
+v_htmlescape= "0.15"
 
 # experimental-io-uring
-tokio-uring = { version = "0.2", optional = true, features = ["bytes"] }
+[target.'cfg(target_os = "linux")'.dependencies]
-actix-server = "2.1" # ensure matching tokio-uring versions
+tokio-uring = { version = "0.3", optional = true, features = ["bytes"] }
+actix-server = { version = "2.1", optional = true } # ensure matching tokio-uring versions
 
 [dev-dependencies]
 actix-rt = "2.7"
-actix-test = "0.1.0-beta.13"
+actix-test = "0.1"
-actix-web = "4.0.0"
+actix-web = "4"
 tempfile = "3.2"

actix-files/README.md

@@ -3,11 +3,11 @@
 > 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)](https://docs.rs/actix-files/0.6.0)
+[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.2)](https://docs.rs/actix-files/0.6.2)
-[![Version](https://img.shields.io/badge/rustc-1.54+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.54.0.html)
+![Version](https://img.shields.io/badge/rustc-1.59+-ab6000.svg)
 ![License](https://img.shields.io/crates/l/actix-files.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-files/0.6.0/status.svg)](https://deps.rs/crate/actix-files/0.6.0)
+[![dependency status](https://deps.rs/crate/actix-files/0.6.2/status.svg)](https://deps.rs/crate/actix-files/0.6.2)
 [![Download](https://img.shields.io/crates/d/actix-files.svg)](https://crates.io/crates/actix-files)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 

actix-files/src/directory.rs

@@ -1,8 +1,8 @@
 use std::{fmt::Write, fs::DirEntry, io, path::Path, path::PathBuf};
 
 use actix_web::{dev::ServiceResponse, HttpRequest, HttpResponse};
-use askama_escape::{escape as escape_html_entity, Html};
 use percent_encoding::{utf8_percent_encode, CONTROLS};
+use v_htmlescape::escape as escape_html_entity;
 
 /// A directory; responds with the generated directory listing.
 #[derive(Debug)]
@@ -59,7 +59,7 @@ macro_rules! encode_file_url {
 /// ```
 macro_rules! encode_file_name {
     ($entry:ident) => {
-        escape_html_entity(&$entry.file_name().to_string_lossy(), Html)
+        escape_html_entity(&$entry.file_name().to_string_lossy())
     };
 }
 

actix-files/src/error.rs

@@ -2,7 +2,7 @@ use actix_web::{http::StatusCode, ResponseError};
 use derive_more::Display;
 
 /// Errors which can occur when serving static files.
-#[derive(Display, Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq, Display)]
 pub enum FilesError {
     /// Path is not a directory
     #[allow(dead_code)]
@@ -22,7 +22,7 @@ impl ResponseError for FilesError {
 }
 
 #[allow(clippy::enum_variant_names)]
-#[derive(Display, Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq, Display)]
 #[non_exhaustive]
 pub enum UriSegmentError {
     /// The segment started with the wrapped invalid character.

actix-files/src/named.rs

@@ -528,11 +528,26 @@ impl NamedFile {
                     length = ranges[0].length;
                     offset = ranges[0].start;
 
+                    // When a Content-Encoding header is present in a 206 partial content response
+                    // for video content, it prevents browser video players from starting playback
+                    // before loading the whole video and also prevents seeking.
+                    //
+                    // See: https://github.com/actix/actix-web/issues/2815
+                    //
+                    // The assumption of this fix is that the video player knows to not send an
+                    // Accept-Encoding header for this request and that downstream middleware will
+                    // not attempt compression for requests without it.
+                    //
+                    // TODO: Solve question around what to do if self.encoding is set and partial
+                    // range is requested. Reject request? Ignoring self.encoding seems wrong, too.
+                    // In practice, it should not come up.
+                    if req.headers().contains_key(&header::ACCEPT_ENCODING) {
                         // don't allow compression middleware to modify partial content
                         res.insert_header((
                             header::CONTENT_ENCODING,
                             HeaderValue::from_static("identity"),
                         ));
+                    }
 
                     res.insert_header((
                         header::CONTENT_RANGE,

actix-files/src/service.rs

@@ -23,7 +23,7 @@ impl Deref for FilesService {
     type Target = FilesServiceInner;
 
     fn deref(&self) -> &Self::Target {
-        &*self.0
+        &self.0
     }
 }
 

actix-files/tests/encoding.rs

@@ -1,11 +1,11 @@
-use actix_files::Files;
+use actix_files::{Files, NamedFile};
 use actix_web::{
     http::{
         header::{self, HeaderValue},
         StatusCode,
     },
     test::{self, TestRequest},
-    App,
+    web, App,
 };
 
 #[actix_web::test]
@@ -36,3 +36,31 @@ async fn test_utf8_file_contents() {
         Some(&HeaderValue::from_static("text/plain")),
     );
 }
+
+#[actix_web::test]
+async fn partial_range_response_encoding() {
+    let srv = test::init_service(App::new().default_service(web::to(|| async {
+        NamedFile::open_async("./tests/test.binary").await.unwrap()
+    })))
+    .await;
+
+    // range request without accept-encoding returns no content-encoding header
+    let req = TestRequest::with_uri("/")
+        .append_header((header::RANGE, "bytes=10-20"))
+        .to_request();
+    let res = test::call_service(&srv, req).await;
+    assert_eq!(res.status(), StatusCode::PARTIAL_CONTENT);
+    assert!(!res.headers().contains_key(header::CONTENT_ENCODING));
+
+    // range request with accept-encoding returns a content-encoding header
+    let req = TestRequest::with_uri("/")
+        .append_header((header::RANGE, "bytes=10-20"))
+        .append_header((header::ACCEPT_ENCODING, "identity"))
+        .to_request();
+    let res = test::call_service(&srv, req).await;
+    assert_eq!(res.status(), StatusCode::PARTIAL_CONTENT);
+    assert_eq!(
+        res.headers().get(header::CONTENT_ENCODING).unwrap(),
+        "identity"
+    );
+}

actix-http-test/CHANGES.md

@@ -1,8 +1,25 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+- Minimum supported Rust version (MSRV) is now 1.59.
 
 
+## 3.0.0 - 2022-07-24
+- `TestServer::stop` is now async and will wait for the server and system to shutdown. [#2442]
+- Added `TestServer::client_headers` method. [#2097]
+- Update `actix-server` dependency to `2`.
+- Update `actix-tls` dependency to `3`.
+- Update `bytes` to `1.0`. [#1813]
+- Minimum supported Rust version (MSRV) is now 1.57.
+
+[#2442]: https://github.com/actix/actix-web/pull/2442
+[#2097]: https://github.com/actix/actix-web/pull/2097
+[#1813]: https://github.com/actix/actix-web/pull/1813
+
+
+<details>
+<summary>3.0.0 Pre-Releases</summary>
+
 ## 3.0.0-beta.13 - 2022-02-16
 - No significant changes since `3.0.0-beta.12`.
 
@@ -68,6 +85,7 @@
 
 [#1813]: https://github.com/actix/actix-web/pull/1813
 
+</details>
 
 ## 2.1.0 - 2020-11-25
 - Add ability to set address for `TestServer`. [#1645]

actix-http-test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http-test"
-version = "3.0.0-beta.13"
+version = "3.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Various helpers for Actix applications to use during testing"
 keywords = ["http", "web", "framework", "async", "futures"]

actix-http-test/README.md

@@ -3,11 +3,11 @@
 > 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.13)](https://docs.rs/actix-http-test/3.0.0-beta.13)
+[![Documentation](https://docs.rs/actix-http-test/badge.svg?version=3.0.0)](https://docs.rs/actix-http-test/3.0.0)
-[![Version](https://img.shields.io/badge/rustc-1.54+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.54.0.html)
+![Version](https://img.shields.io/badge/rustc-1.59+-ab6000.svg)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http-test)
 <br>
-[![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0-beta.13/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0-beta.13)
+[![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0)
 [![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)
 

actix-http/CHANGES.md

@@ -1,6 +1,56 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+### Added
+- Implement `MessageBody` for `&mut B` where `B: MessageBody + Unpin`. [#2868]
+- Implement `MessageBody` for `Pin<B>` where `B::Target: MessageBody`. [#2868]
+
+### Performance
+- Improve overall performance of operations on `Extensions`. [#2890]
+
+[#2868]: https://github.com/actix/actix-web/pull/2868
+[#2890]: https://github.com/actix/actix-web/pull/2890
+
+
+## 3.2.2 - 2022-09-11
+### Changed
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.
+
+### Fixed
+- Avoid possibility of dispatcher getting stuck while back-pressuring I/O. [#2369]
+
+[#2369]: https://github.com/actix/actix-web/pull/2369
+
+
+## 3.2.1 - 2022-07-02
+### Fixed
+- Fix parsing ambiguity in Transfer-Encoding and Content-Length headers for HTTP/1.0 requests. [#2794]
+
+[#2794]: https://github.com/actix/actix-web/pull/2794
+
+
+## 3.2.0 - 2022-06-30
+### Changed
+- Minimum supported Rust version (MSRV) is now 1.57 due to transitive `time` dependency.
+
+### Fixed
+- Websocket parser no longer throws endless overflow errors after receiving an oversized frame. [#2790]
+- Retain previously set Vary headers when using compression encoder. [#2798]
+
+[#2790]: https://github.com/actix/actix-web/pull/2790
+[#2798]: https://github.com/actix/actix-web/pull/2798
+
+
+## 3.1.0 - 2022-06-11
+### Changed
+- Minimum supported Rust version (MSRV) is now 1.56 due to transitive `hashbrown` dependency.
+
+### Fixed
+- Revert broken fix in [#2624] that caused erroneous 500 error responses. Temporarily re-introduces [#2357] bug. [#2779]
+
+[#2624]: https://github.com/actix/actix-web/pull/2624
+[#2357]: https://github.com/actix/actix-web/issues/2357
+[#2779]: https://github.com/actix/actix-web/pull/2779
 
 
 ## 3.0.4 - 2022-03-09
@@ -12,14 +62,14 @@
 ### Fixed
 - Allow spaces between header name and colon when parsing responses. [#2684]
 
-[#2684]: https://github.com/actix/actix-web/issues/2684
+[#2684]: https://github.com/actix/actix-web/pull/2684
 
 
 ## 3.0.2 - 2022-03-05
 ### Fixed
 - Fix encoding camel-case header names with more than one hyphen. [#2683]
 
-[#2683]: https://github.com/actix/actix-web/issues/2683
+[#2683]: https://github.com/actix/actix-web/pull/2683
 
 
 ## 3.0.1 - 2022-03-04

actix-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "3.0.4"
+version = "3.2.2"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Rob Ede <robjtede@icloud.com>",
@@ -37,7 +37,7 @@ ws = [
     "local-channel",
     "base64",
     "rand",
-    "sha-1",
+    "sha1",
 ]
 
 # TLS via OpenSSL
@@ -86,7 +86,7 @@ h2 = { version = "0.3.9", optional = true }
 local-channel = { version = "0.1", optional = true }
 base64 = { version = "0.13", optional = true }
 rand = { version = "0.8", optional = true }
-sha-1 = { version = "0.10", optional = true }
+sha1 = { version = "0.10", optional = true }
 
 # openssl/rustls
 actix-tls = { version = "3", default-features = false, optional = true }
@@ -94,13 +94,13 @@ actix-tls = { version = "3", default-features = false, optional = true }
 # compress-*
 brotli = { version = "3.3.3", optional = true }
 flate2 = { version = "1.0.13", optional = true }
-zstd = { version = "0.10", optional = true }
+zstd = { version = "0.11", optional = true }
 
 [dev-dependencies]
-actix-http-test = { version = "3.0.0-beta.13", features = ["openssl"] }
+actix-http-test = { version = "3", features = ["openssl"] }
 actix-server = "2"
 actix-tls = { version = "3", features = ["openssl"] }
-actix-web = "4.0.0"
+actix-web = "4"
 
 async-stream = "0.3"
 criterion = { version = "0.3", features = ["html_reports"] }
@@ -108,10 +108,10 @@ env_logger = "0.9"
 futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
 memchr = "2.4"
 once_cell = "1.9"
-rcgen = "0.8"
+rcgen = "0.9"
 regex = "1.3"
 rustversion = "1"
-rustls-pemfile = "0.2"
+rustls-pemfile = "1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 static_assertions = "1"

actix-http/README.md

@@ -3,11 +3,11 @@
 > 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.4)](https://docs.rs/actix-http/3.0.4)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.2.2)](https://docs.rs/actix-http/3.2.2)
-[![Version](https://img.shields.io/badge/rustc-1.54+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.54.0.html)
+![Version](https://img.shields.io/badge/rustc-1.59+-ab6000.svg)
 ![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.4/status.svg)](https://deps.rs/crate/actix-http/3.0.4)
+[![dependency status](https://deps.rs/crate/actix-http/3.2.2/status.svg)](https://deps.rs/crate/actix-http/3.2.2)
 [![Download](https://img.shields.io/crates/d/actix-http.svg)](https://crates.io/crates/actix-http)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 

actix-http/benches/uninit-headers.rs

@@ -114,11 +114,12 @@ mod _original {
     use std::mem::MaybeUninit;
 
     pub fn parse_headers(src: &mut BytesMut) -> usize {
-        #![allow(clippy::uninit_assumed_init)]
+        #![allow(invalid_value, clippy::uninit_assumed_init)]
 
         let mut headers: [HeaderIndex; MAX_HEADERS] =
             unsafe { MaybeUninit::uninit().assume_init() };
 
+        #[allow(invalid_value)]
         let mut parsed: [httparse::Header<'_>; MAX_HEADERS] =
             unsafe { MaybeUninit::uninit().assume_init() };
 

actix-http/src/body/message_body.rs

@@ -120,8 +120,28 @@ pub trait MessageBody {
 }
 
 mod foreign_impls {
+    use std::ops::DerefMut;
+
     use super::*;
 
+    impl<B> MessageBody for &mut B
+    where
+        B: MessageBody + Unpin + ?Sized,
+    {
+        type Error = B::Error;
+
+        fn size(&self) -> BodySize {
+            (**self).size()
+        }
+
+        fn poll_next(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            Pin::new(&mut **self).poll_next(cx)
+        }
+    }
+
     impl MessageBody for Infallible {
         type Error = Infallible;
 
@@ -179,8 +199,9 @@ mod foreign_impls {
         }
     }
 
-    impl<B> MessageBody for Pin<Box<B>>
+    impl<T, B> MessageBody for Pin<T>
     where
+        T: DerefMut<Target = B> + Unpin,
         B: MessageBody + ?Sized,
     {
         type Error = B::Error;
@@ -445,6 +466,7 @@ mod tests {
     use actix_rt::pin;
     use actix_utils::future::poll_fn;
     use bytes::{Bytes, BytesMut};
+    use futures_util::stream;
 
     use super::*;
     use crate::body::{self, EitherBody};
@@ -481,6 +503,35 @@ mod tests {
         assert_poll_next_none!(pl);
     }
 
+    #[actix_rt::test]
+    async fn mut_equivalence() {
+        assert_eq!(().size(), BodySize::Sized(0));
+        assert_eq!(().size(), (&(&mut ())).size());
+
+        let pl = &mut ();
+        pin!(pl);
+        assert_poll_next_none!(pl);
+
+        let pl = &mut Box::new(());
+        pin!(pl);
+        assert_poll_next_none!(pl);
+
+        let mut body = body::SizedStream::new(
+            8,
+            stream::iter([
+                Ok::<_, std::io::Error>(Bytes::from("1234")),
+                Ok(Bytes::from("5678")),
+            ]),
+        );
+        let body = &mut body;
+        assert_eq!(body.size(), BodySize::Sized(8));
+        pin!(body);
+        assert_poll_next!(body, Bytes::from_static(b"1234"));
+        assert_poll_next!(body, Bytes::from_static(b"5678"));
+        assert_poll_next_none!(body);
+    }
+
+    #[allow(clippy::let_unit_value)]
     #[actix_rt::test]
     async fn test_unit() {
         let pl = ();
@@ -606,4 +657,18 @@ mod tests {
         let not_body = resp_body.downcast_ref::<()>();
         assert!(not_body.is_none());
     }
+
+    #[actix_rt::test]
+    async fn non_owning_to_bytes() {
+        let mut body = BoxBody::new(());
+        let bytes = body::to_bytes(&mut body).await.unwrap();
+        assert_eq!(bytes, Bytes::new());
+
+        let mut body = body::BodyStream::new(stream::iter([
+            Ok::<_, std::io::Error>(Bytes::from("1234")),
+            Ok(Bytes::from("5678")),
+        ]));
+        let bytes = body::to_bytes(&mut body).await.unwrap();
+        assert_eq!(bytes, Bytes::from_static(b"12345678"));
+    }
 }

actix-http/src/body/utils.rs

@@ -42,7 +42,7 @@ pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
         let body = body.as_mut();
 
         match ready!(body.poll_next(cx)) {
-            Some(Ok(bytes)) => buf.extend_from_slice(&*bytes),
+            Some(Ok(bytes)) => buf.extend_from_slice(&bytes),
             None => return Poll::Ready(Ok(())),
             Some(Err(err)) => return Poll::Ready(Err(err)),
         }

actix-http/src/builder.rs

@@ -211,6 +211,7 @@ where
 
     /// Finish service configuration and create a HTTP service for HTTP/2 protocol.
     #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
     pub fn h2<F, B>(self, service: F) -> crate::h2::H2Service<T, S, B>
     where
         F: IntoServiceFactory<S, Request>,

actix-http/src/config.rs

@@ -35,7 +35,7 @@ impl Default for ServiceConfig {
 }
 
 impl ServiceConfig {
-    /// Create instance of `ServiceConfig`
+    /// Create instance of `ServiceConfig`.
     pub fn new(
         keep_alive: KeepAlive,
         client_request_timeout: Duration,

actix-http/src/encoding/encoder.rs

@@ -257,7 +257,7 @@ fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
     head.headers_mut()
         .insert(header::CONTENT_ENCODING, encoding.to_header_value());
     head.headers_mut()
-        .insert(header::VARY, HeaderValue::from_static("accept-encoding"));
+        .append(header::VARY, HeaderValue::from_static("accept-encoding"));
 
     head.no_chunking(false);
 }

actix-http/src/error.rs

@@ -294,6 +294,7 @@ impl std::error::Error for PayloadError {
             PayloadError::Overflow => None,
             PayloadError::UnknownLength => None,
             #[cfg(feature = "http2")]
+            #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
             PayloadError::Http2Payload(err) => Some(err),
             PayloadError::Io(err) => Some(err),
         }
@@ -351,6 +352,7 @@ pub enum DispatchError {
     /// HTTP/2 error.
     #[display(fmt = "{}", _0)]
     #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
     H2(h2::Error),
 
     /// The first request did not complete within the specified timeout.
@@ -388,7 +390,7 @@ impl StdError for DispatchError {
 
 /// A set of error that can occur during parsing content type.
 #[derive(Debug, Display, Error)]
-#[cfg_attr(test, derive(PartialEq))]
+#[cfg_attr(test, derive(PartialEq, Eq))]
 #[non_exhaustive]
 pub enum ContentTypeError {
     /// Can not parse content type

actix-http/src/extensions.rs

@@ -1,9 +1,30 @@
 use std::{
     any::{Any, TypeId},
+    collections::HashMap,
     fmt,
+    hash::{BuildHasherDefault, Hasher},
 };
 
-use ahash::AHashMap;
+/// A hasher for `TypeId`s that takes advantage of its known characteristics.
+///
+/// Author of `anymap` crate has done research on the topic:
+/// https://github.com/chris-morgan/anymap/blob/2e9a5704/src/lib.rs#L599
+#[derive(Debug, Default)]
+struct NoOpHasher(u64);
+
+impl Hasher for NoOpHasher {
+    fn write(&mut self, _bytes: &[u8]) {
+        unimplemented!("This NoOpHasher can only handle u64s")
+    }
+
+    fn write_u64(&mut self, i: u64) {
+        self.0 = i;
+    }
+
+    fn finish(&self) -> u64 {
+        self.0
+    }
+}
 
 /// A type map for request extensions.
 ///
@@ -11,7 +32,7 @@ use ahash::AHashMap;
 #[derive(Default)]
 pub struct Extensions {
     /// Use AHasher with a std HashMap with for faster lookups on the small `TypeId` keys.
-    map: AHashMap<TypeId, Box<dyn Any>>,
+    map: HashMap<TypeId, Box<dyn Any>, BuildHasherDefault<NoOpHasher>>,
 }
 
 impl Extensions {
@@ -19,7 +40,7 @@ impl Extensions {
     #[inline]
     pub fn new() -> Extensions {
         Extensions {
-            map: AHashMap::new(),
+            map: HashMap::default(),
         }
     }
 

actix-http/src/h1/chunked.rs

@@ -15,7 +15,7 @@ macro_rules! byte (
     })
 );
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) enum ChunkedState {
     Size,
     SizeLws,

actix-http/src/h1/decoder.rs

@@ -46,6 +46,23 @@ pub(crate) enum PayloadLength {
     None,
 }
 
+impl PayloadLength {
+    /// Returns true if variant is `None`.
+    fn is_none(&self) -> bool {
+        matches!(self, Self::None)
+    }
+
+    /// Returns true if variant is represents zero-length (not none) payload.
+    fn is_zero(&self) -> bool {
+        matches!(
+            self,
+            PayloadLength::Payload(PayloadType::Payload(PayloadDecoder {
+                kind: Kind::Length(0)
+            }))
+        )
+    }
+}
+
 pub(crate) trait MessageType: Sized {
     fn set_connection_type(&mut self, conn_type: Option<ConnectionType>);
 
@@ -59,6 +76,7 @@ pub(crate) trait MessageType: Sized {
         &mut self,
         slice: &Bytes,
         raw_headers: &[HeaderIndex],
+        version: Version,
     ) -> Result<PayloadLength, ParseError> {
         let mut ka = None;
         let mut has_upgrade_websocket = false;
@@ -87,21 +105,23 @@ pub(crate) trait MessageType: Sized {
                         return Err(ParseError::Header);
                     }
 
-                    header::CONTENT_LENGTH => match value.to_str() {
+                    header::CONTENT_LENGTH => match value.to_str().map(str::trim) {
-                        Ok(s) if s.trim().starts_with('+') => {
+                        Ok(val) if val.starts_with('+') => {
-                            debug!("illegal Content-Length: {:?}", s);
+                            debug!("illegal Content-Length: {:?}", val);
                             return Err(ParseError::Header);
                         }
-                        Ok(s) => {
+
-                            if let Ok(len) = s.parse::<u64>() {
+                        Ok(val) => {
-                                if len != 0 {
+                            if let Ok(len) = val.parse::<u64>() {
+                                // accept 0 lengths here and remove them in `decode` after all
+                                // headers have been processed to prevent request smuggling issues
                                 content_length = Some(len);
-                                }
                             } else {
-                                debug!("illegal Content-Length: {:?}", s);
+                                debug!("illegal Content-Length: {:?}", val);
                                 return Err(ParseError::Header);
                             }
                         }
+
                         Err(_) => {
                             debug!("illegal Content-Length: {:?}", value);
                             return Err(ParseError::Header);
@@ -114,22 +134,23 @@ pub(crate) trait MessageType: Sized {
                         return Err(ParseError::Header);
                     }
 
-                    header::TRANSFER_ENCODING => {
+                    header::TRANSFER_ENCODING if version == Version::HTTP_11 => {
                         seen_te = true;
 
-                        if let Ok(s) = value.to_str().map(str::trim) {
+                        if let Ok(val) = value.to_str().map(str::trim) {
-                            if s.eq_ignore_ascii_case("chunked") {
+                            if val.eq_ignore_ascii_case("chunked") {
                                 chunked = true;
-                            } else if s.eq_ignore_ascii_case("identity") {
+                            } else if val.eq_ignore_ascii_case("identity") {
                                 // allow silently since multiple TE headers are already checked
                             } else {
-                                debug!("illegal Transfer-Encoding: {:?}", s);
+                                debug!("illegal Transfer-Encoding: {:?}", val);
                                 return Err(ParseError::Header);
                             }
                         } else {
                             return Err(ParseError::Header);
                         }
                     }
+
                     // connection keep-alive state
                     header::CONNECTION => {
                         ka = if let Ok(conn) = value.to_str().map(str::trim) {
@@ -146,6 +167,7 @@ pub(crate) trait MessageType: Sized {
                             None
                         };
                     }
+
                     header::UPGRADE => {
                         if let Ok(val) = value.to_str().map(str::trim) {
                             if val.eq_ignore_ascii_case("websocket") {
@@ -153,19 +175,23 @@ pub(crate) trait MessageType: Sized {
                             }
                         }
                     }
+
                     header::EXPECT => {
                         let bytes = value.as_bytes();
                         if bytes.len() >= 4 && &bytes[0..4] == b"100-" {
                             expect = true;
                         }
                     }
+
                     _ => {}
                 }
 
                 headers.append(name, value);
             }
         }
+
         self.set_connection_type(ka);
+
         if expect {
             self.set_expect()
         }
@@ -249,7 +275,22 @@ impl MessageType for Request {
         let mut msg = Request::new();
 
         // convert headers
-        let length = msg.set_headers(&src.split_to(len).freeze(), &headers[..h_len])?;
+        let mut length =
+            msg.set_headers(&src.split_to(len).freeze(), &headers[..h_len], ver)?;
+
+        // disallow HTTP/1.0 POST requests that do not contain a Content-Length headers
+        // see https://datatracker.ietf.org/doc/html/rfc1945#section-7.2.2
+        if ver == Version::HTTP_10 && method == Method::POST && length.is_none() {
+            debug!("no Content-Length specified for HTTP/1.0 POST request");
+            return Err(ParseError::Header);
+        }
+
+        // Remove CL value if 0 now that all headers and HTTP/1.0 special cases are processed.
+        // Protects against some request smuggling attacks.
+        // See https://github.com/actix/actix-web/issues/2767.
+        if length.is_zero() {
+            length = PayloadLength::None;
+        }
 
         // payload decoder
         let decoder = match length {
@@ -337,7 +378,15 @@ impl MessageType for ResponseHead {
         msg.version = ver;
 
         // convert headers
-        let length = msg.set_headers(&src.split_to(len).freeze(), &headers[..h_len])?;
+        let mut length =
+            msg.set_headers(&src.split_to(len).freeze(), &headers[..h_len], ver)?;
+
+        // Remove CL value if 0 now that all headers and HTTP/1.0 special cases are processed.
+        // Protects against some request smuggling attacks.
+        // See https://github.com/actix/actix-web/issues/2767.
+        if length.is_zero() {
+            length = PayloadLength::None;
+        }
 
         // message payload
         let decoder = if let PayloadLength::Payload(pl) = length {
@@ -391,7 +440,7 @@ impl HeaderIndex {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 /// Chunk type yielded while decoding a payload.
 pub enum PayloadItem {
     Chunk(Bytes),
@@ -401,7 +450,7 @@ pub enum PayloadItem {
 /// Decoder that can handle different payload types.
 ///
 /// If a message body does not use `Transfer-Encoding`, it should include a `Content-Length`.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PayloadDecoder {
     kind: Kind,
 }
@@ -427,7 +476,7 @@ impl PayloadDecoder {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 enum Kind {
     /// A reader used when a `Content-Length` header is passed with a positive integer.
     Length(u64),
@@ -606,14 +655,100 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_post() {
+    fn parse_h09_reject() {
-        let mut buf = BytesMut::from("POST /test2 HTTP/1.0\r\n\r\n");
+        let mut buf = BytesMut::from(
+            "GET /test1 HTTP/0.9\r\n\
+            \r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        reader.decode(&mut buf).unwrap_err();
+
+        let mut buf = BytesMut::from(
+            "POST /test2 HTTP/0.9\r\n\
+            Content-Length: 3\r\n\
+            \r\n
+            abc",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        reader.decode(&mut buf).unwrap_err();
+    }
+
+    #[test]
+    fn parse_h10_get() {
+        let mut buf = BytesMut::from(
+            "GET /test1 HTTP/1.0\r\n\
+            \r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(req.version(), Version::HTTP_10);
+        assert_eq!(*req.method(), Method::GET);
+        assert_eq!(req.path(), "/test1");
+
+        let mut buf = BytesMut::from(
+            "GET /test2 HTTP/1.0\r\n\
+            Content-Length: 0\r\n\
+            \r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(req.version(), Version::HTTP_10);
+        assert_eq!(*req.method(), Method::GET);
+        assert_eq!(req.path(), "/test2");
+
+        let mut buf = BytesMut::from(
+            "GET /test3 HTTP/1.0\r\n\
+            Content-Length: 3\r\n\
+            \r\n
+            abc",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(req.version(), Version::HTTP_10);
+        assert_eq!(*req.method(), Method::GET);
+        assert_eq!(req.path(), "/test3");
+    }
+
+    #[test]
+    fn parse_h10_post() {
+        let mut buf = BytesMut::from(
+            "POST /test1 HTTP/1.0\r\n\
+            Content-Length: 3\r\n\
+            \r\n\
+            abc",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(req.version(), Version::HTTP_10);
+        assert_eq!(*req.method(), Method::POST);
+        assert_eq!(req.path(), "/test1");
+
+        let mut buf = BytesMut::from(
+            "POST /test2 HTTP/1.0\r\n\
+            Content-Length: 0\r\n\
+            \r\n",
+        );
 
         let mut reader = MessageDecoder::<Request>::default();
         let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
         assert_eq!(req.version(), Version::HTTP_10);
         assert_eq!(*req.method(), Method::POST);
         assert_eq!(req.path(), "/test2");
+
+        let mut buf = BytesMut::from(
+            "POST /test3 HTTP/1.0\r\n\
+            \r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let err = reader.decode(&mut buf).unwrap_err();
+        assert!(err.to_string().contains("Header"))
     }
 
     #[test]
@@ -709,121 +844,98 @@ mod tests {
 
     #[test]
     fn test_conn_default_1_0() {
-        let mut buf = BytesMut::from("GET /test HTTP/1.0\r\n\r\n");
+        let req = parse_ready!(&mut BytesMut::from("GET /test HTTP/1.0\r\n\r\n"));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::Close);
     }
 
     #[test]
     fn test_conn_default_1_1() {
-        let mut buf = BytesMut::from("GET /test HTTP/1.1\r\n\r\n");
+        let req = parse_ready!(&mut BytesMut::from("GET /test HTTP/1.1\r\n\r\n"));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::KeepAlive);
     }
 
     #[test]
     fn test_conn_close() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              connection: close\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::Close);
 
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              connection: Close\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::Close);
     }
 
     #[test]
     fn test_conn_close_1_0() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.0\r\n\
              connection: close\r\n\r\n",
-        );
+        ));
-
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::Close);
     }
 
     #[test]
     fn test_conn_keep_alive_1_0() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.0\r\n\
              connection: keep-alive\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::KeepAlive);
 
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.0\r\n\
              connection: Keep-Alive\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::KeepAlive);
     }
 
     #[test]
     fn test_conn_keep_alive_1_1() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              connection: keep-alive\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::KeepAlive);
     }
 
     #[test]
     fn test_conn_other_1_0() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.0\r\n\
              connection: other\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::Close);
     }
 
     #[test]
     fn test_conn_other_1_1() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              connection: other\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.head().connection_type(), ConnectionType::KeepAlive);
     }
 
     #[test]
     fn test_conn_upgrade() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              upgrade: websockets\r\n\
              connection: upgrade\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
 
         assert!(req.upgrade());
         assert_eq!(req.head().connection_type(), ConnectionType::Upgrade);
 
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              upgrade: Websockets\r\n\
              connection: Upgrade\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
 
         assert!(req.upgrade());
         assert_eq!(req.head().connection_type(), ConnectionType::Upgrade);
@@ -831,59 +943,62 @@ mod tests {
 
     #[test]
     fn test_conn_upgrade_connect_method() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "CONNECT /test HTTP/1.1\r\n\
              content-type: text/plain\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
 
         assert!(req.upgrade());
     }
 
     #[test]
-    fn test_headers_content_length_err_1() {
+    fn test_headers_bad_content_length() {
-        let mut buf = BytesMut::from(
+        // string CL
+        expect_parse_err!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              content-length: line\r\n\r\n",
-        );
+        ));
 
-        expect_parse_err!(&mut buf)
+        // negative CL
+        expect_parse_err!(&mut BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             content-length: -1\r\n\r\n",
+        ));
     }
 
     #[test]
-    fn test_headers_content_length_err_2() {
+    fn octal_ish_cl_parsed_as_decimal() {
         let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
+            "POST /test HTTP/1.1\r\n\
-             content-length: -1\r\n\r\n",
+             content-length: 011\r\n\r\n",
         );
-
+        let mut reader = MessageDecoder::<Request>::default();
-        expect_parse_err!(&mut buf);
+        let (_req, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        assert!(matches!(
+            pl,
+            PayloadType::Payload(pl) if pl == PayloadDecoder::length(11)
+        ));
     }
 
     #[test]
     fn test_invalid_header() {
-        let mut buf = BytesMut::from(
+        expect_parse_err!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              test line\r\n\r\n",
-        );
+        ));
-
-        expect_parse_err!(&mut buf);
     }
 
     #[test]
     fn test_invalid_name() {
-        let mut buf = BytesMut::from(
+        expect_parse_err!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              test[]: line\r\n\r\n",
-        );
+        ));
-
-        expect_parse_err!(&mut buf);
     }
 
     #[test]
     fn test_http_request_bad_status_line() {
-        let mut buf = BytesMut::from("getpath \r\n\r\n");
+        expect_parse_err!(&mut BytesMut::from("getpath \r\n\r\n"));
-        expect_parse_err!(&mut buf);
     }
 
     #[test]
@@ -923,11 +1038,10 @@ mod tests {
 
     #[test]
     fn test_http_request_parser_utf8() {
-        let mut buf = BytesMut::from(
+        let req = parse_ready!(&mut BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              x-test: тест\r\n\r\n",
-        );
+        ));
-        let req = parse_ready!(&mut buf);
 
         assert_eq!(
             req.headers().get("x-test").unwrap().as_bytes(),
@@ -937,24 +1051,18 @@ mod tests {
 
     #[test]
     fn test_http_request_parser_two_slashes() {
-        let mut buf = BytesMut::from("GET //path HTTP/1.1\r\n\r\n");
+        let req = parse_ready!(&mut BytesMut::from("GET //path HTTP/1.1\r\n\r\n"));
-        let req = parse_ready!(&mut buf);
-
         assert_eq!(req.path(), "//path");
     }
 
     #[test]
     fn test_http_request_parser_bad_method() {
-        let mut buf = BytesMut::from("!12%()+=~$ /get HTTP/1.1\r\n\r\n");
+        expect_parse_err!(&mut BytesMut::from("!12%()+=~$ /get HTTP/1.1\r\n\r\n"));
-
-        expect_parse_err!(&mut buf);
     }
 
     #[test]
     fn test_http_request_parser_bad_version() {
-        let mut buf = BytesMut::from("GET //get HT/11\r\n\r\n");
+        expect_parse_err!(&mut BytesMut::from("GET //get HT/11\r\n\r\n"));
-
-        expect_parse_err!(&mut buf);
     }
 
     #[test]
@@ -971,29 +1079,66 @@ mod tests {
 
     #[test]
     fn hrs_multiple_content_length() {
-        let mut buf = BytesMut::from(
+        expect_parse_err!(&mut 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);
+        expect_parse_err!(&mut BytesMut::from(
+            "GET / HTTP/1.1\r\n\
+            Host: example.com\r\n\
+            Content-Length: 0\r\n\
+            Content-Length: 2\r\n\
+            \r\n\
+            ab",
+        ));
     }
 
     #[test]
     fn hrs_content_length_plus() {
-        let mut buf = BytesMut::from(
+        expect_parse_err!(&mut BytesMut::from(
             "GET / HTTP/1.1\r\n\
             Host: example.com\r\n\
             Content-Length: +3\r\n\
             \r\n\
             000",
+        ));
+    }
+
+    #[test]
+    fn hrs_te_http10() {
+        // in HTTP/1.0 transfer encoding is ignored and must therefore contain a CL header
+
+        expect_parse_err!(&mut BytesMut::from(
+            "POST / HTTP/1.0\r\n\
+            Host: example.com\r\n\
+            Transfer-Encoding: chunked\r\n\
+            \r\n\
+            3\r\n\
+            aaa\r\n\
+            0\r\n\
+            ",
+        ));
+    }
+
+    #[test]
+    fn hrs_cl_and_te_http10() {
+        // in HTTP/1.0 transfer encoding is simply ignored so it's fine to have both
+
+        let mut buf = BytesMut::from(
+            "GET / HTTP/1.0\r\n\
+            Host: example.com\r\n\
+            Content-Length: 3\r\n\
+            Transfer-Encoding: chunked\r\n\
+            \r\n\
+            000",
         );
 
-        expect_parse_err!(&mut buf);
+        parse_ready!(&mut buf);
     }
 
     #[test]

actix-http/src/h1/dispatcher.rs

@@ -15,14 +15,14 @@ use bitflags::bitflags;
 use bytes::{Buf, BytesMut};
 use futures_core::ready;
 use pin_project_lite::pin_project;
-use tracing::{debug, error, trace};
+use tracing::{error, trace};
 
 use crate::{
     body::{BodySize, BoxBody, MessageBody},
     config::ServiceConfig,
     error::{DispatchError, ParseError, PayloadError},
     service::HttpFlow,
-    ConnectionType, Error, Extensions, OnConnectData, Request, Response, StatusCode,
+    Error, Extensions, OnConnectData, Request, Response, StatusCode,
 };
 
 use super::{
@@ -691,74 +691,12 @@ where
         let can_not_read = !self.can_read(cx);
 
         // limit amount of non-processed requests
-        if pipeline_queue_full {
+        if pipeline_queue_full || can_not_read {
             return Ok(false);
         }
 
         let mut this = self.as_mut().project();
 
-        if can_not_read {
-            debug!("cannot read request payload");
-
-            if let Some(sender) = &this.payload {
-                // ...maybe handler does not want to read any more payload...
-                if let PayloadStatus::Dropped = sender.need_read(cx) {
-                    debug!("handler dropped payload early; attempt to clean connection");
-                    // ...in which case poll request payload a few times
-                    loop {
-                        match this.codec.decode(this.read_buf)? {
-                            Some(msg) => {
-                                match msg {
-                                    // payload decoded did not yield EOF yet
-                                    Message::Chunk(Some(_)) => {
-                                        // if non-clean connection, next loop iter will detect empty
-                                        // read buffer and close connection
-                                    }
-
-                                    // connection is in clean state for next request
-                                    Message::Chunk(None) => {
-                                        debug!("connection successfully cleaned");
-
-                                        // reset dispatcher state
-                                        let _ = this.payload.take();
-                                        this.state.set(State::None);
-
-                                        // break out of payload decode loop
-                                        break;
-                                    }
-
-                                    // Either whole payload is read and loop is broken or more data
-                                    // was expected in which case connection is closed. In both
-                                    // situations dispatcher cannot get here.
-                                    Message::Item(_) => {
-                                        unreachable!("dispatcher is in payload receive state")
-                                    }
-                                }
-                            }
-
-                            // not enough info to decide if connection is going to be clean or not
-                            None => {
-                                error!(
-                                    "handler did not read whole payload and dispatcher could not \
-                                    drain read buf; return 500 and close connection"
-                                );
-
-                                this.flags.insert(Flags::SHUTDOWN);
-                                let mut res = Response::internal_server_error().drop_body();
-                                res.head_mut().set_connection_type(ConnectionType::Close);
-                                this.messages.push_back(DispatcherMessage::Error(res));
-                                *this.error = Some(DispatchError::HandlerDroppedPayload);
-                                return Ok(true);
-                            }
-                        }
-                    }
-                }
-            } else {
-                // can_not_read and no request payload
-                return Ok(false);
-            }
-        }
-
         let mut updated = false;
 
         // decode from read buf as many full requests as possible
@@ -904,10 +842,7 @@ where
             if timer.as_mut().poll(cx).is_ready() {
                 // timeout on first request (slow request) return 408
 
-                trace!(
+                trace!("timed out on slow request; replying with 408 and closing connection");
-                    "timed out on slow request; \
-                        replying with 408 and closing connection"
-                );
 
                 let _ = self.as_mut().send_error_response(
                     Response::with_body(StatusCode::REQUEST_TIMEOUT, ()),
@@ -1041,9 +976,11 @@ where
                 //
                 // A Request head too large to parse is only checked on `httparse::Status::Partial`.
 
-                if this.payload.is_none() {
+                match this.payload {
-                    // When dispatcher has a payload the responsibility of wake up it would be shift
+                    // When dispatcher has a payload the responsibility of wake ups is shifted to
-                    // to h1::payload::Payload.
+                    // `h1::payload::Payload` unless the payload is needing a read, in which case it
+                    // might not have access to the waker and could result in the dispatcher
+                    // getting stuck until timeout.
                     //
                     // Reason:
                     // Self wake up when there is payload would waste poll and/or result in
@@ -1054,7 +991,8 @@ where
                     // read anymore. At this case read_buf could always remain beyond
                     // MAX_BUFFER_SIZE and self wake up would be busy poll dispatcher and
                     // waste resources.
-                    cx.waker().wake_by_ref();
+                    Some(ref p) if p.need_read(cx) != PayloadStatus::Read => {}
+                    _ => cx.waker().wake_by_ref(),
                 }
 
                 return Ok(false);

actix-http/src/h1/dispatcher_tests.rs

@@ -637,7 +637,7 @@ async fn expect_handling() {
 
         if let DispatcherState::Normal { ref inner } = h1.inner {
             let io = inner.io.as_ref().unwrap();
-            let mut res = (&io.write_buf()[..]).to_owned();
+            let mut res = io.write_buf()[..].to_owned();
             stabilize_date_header(&mut res);
 
             assert_eq!(
@@ -699,7 +699,7 @@ async fn expect_eager() {
 
         if let DispatcherState::Normal { ref inner } = h1.inner {
             let io = inner.io.as_ref().unwrap();
-            let mut res = (&io.write_buf()[..]).to_owned();
+            let mut res = io.write_buf()[..].to_owned();
             stabilize_date_header(&mut res);
 
             // Despite the content-length header and even though the request payload has not
@@ -783,6 +783,9 @@ async fn upgrade_handling() {
     .await;
 }
 
+// fix in #2624 reverted temporarily
+// complete fix tracked in #2745
+#[ignore]
 #[actix_rt::test]
 async fn handler_drop_payload() {
     let _ = env_logger::try_init();

actix-http/src/h1/payload.rs

@@ -16,7 +16,7 @@ use crate::error::PayloadError;
 /// max buffer size 32k
 pub(crate) const MAX_BUFFER_SIZE: usize = 32_768;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum PayloadStatus {
     Read,
     Pause,
@@ -252,21 +252,15 @@ impl Inner {
 
 #[cfg(test)]
 mod tests {
-    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_not_impl_any!(Payload: Send, Sync);
 
     assert_impl_all!(Inner: Unpin, Send, Sync);
-    #[rustversion::before(1.60)]
-    assert_not_impl_any!(Inner: UnwindSafe, RefUnwindSafe);
-    #[rustversion::since(1.60)]
-    assert_impl_all!(Inner: UnwindSafe, RefUnwindSafe);
 
     #[actix_rt::test]
     async fn test_unread_data() {

actix-http/src/h1/service.rs

@@ -134,6 +134,7 @@ mod openssl {
         U::InitError: fmt::Debug,
     {
         /// Create OpenSSL based service.
+        #[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
         pub fn openssl(
             self,
             acceptor: SslAcceptor,
@@ -196,6 +197,7 @@ mod rustls {
         U::InitError: fmt::Debug,
     {
         /// Create Rustls based service.
+        #[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
         pub fn rustls(
             self,
             config: ServerConfig,

actix-http/src/h2/dispatcher.rs

@@ -67,7 +67,7 @@ where
                     timer
                 })
                 .unwrap_or_else(|| Box::pin(sleep(dur))),
-            on_flight: false,
+            in_flight: false,
             ping_pong: conn.ping_pong().unwrap(),
         });
 
@@ -84,9 +84,14 @@ where
 }
 
 struct H2PingPong {
-    timer: Pin<Box<Sleep>>,
+    /// Handle to send ping frames from the peer.
-    on_flight: bool,
     ping_pong: PingPong,
+
+    /// True when a ping has been sent and is waiting for a reply.
+    in_flight: bool,
+
+    /// Timeout for pong response.
+    timer: Pin<Box<Sleep>>,
 }
 
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
@@ -152,26 +157,28 @@ where
                     });
                 }
                 Poll::Ready(None) => return Poll::Ready(Ok(())),
+
                 Poll::Pending => match this.ping_pong.as_mut() {
                     Some(ping_pong) => loop {
-                        if ping_pong.on_flight {
+                        if ping_pong.in_flight {
-                            // When have on flight ping pong. poll pong and and keep alive timer.
+                            // When there is an in-flight ping-pong, poll pong and and keep-alive
-                            // on success pong received update keep alive timer to determine the next timing of
+                            // timer. On successful pong received, update keep-alive timer to
-                            // ping pong.
+                            // determine the next timing of ping pong.
                             match ping_pong.ping_pong.poll_pong(cx)? {
                                 Poll::Ready(_) => {
-                                    ping_pong.on_flight = false;
+                                    ping_pong.in_flight = false;
 
                                     let dead_line = this.config.keep_alive_deadline().unwrap();
                                     ping_pong.timer.as_mut().reset(dead_line.into());
                                 }
                                 Poll::Pending => {
-                                    return ping_pong.timer.as_mut().poll(cx).map(|_| Ok(()))
+                                    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
+                            // When there is no in-flight ping-pong, keep-alive timer is used to
-                            // timing of ping pong. Therefore at this point it serves as an interval instead.
+                            // 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())?;
@@ -179,7 +186,7 @@ where
                             let dead_line = this.config.keep_alive_deadline().unwrap();
                             ping_pong.timer.as_mut().reset(dead_line.into());
 
-                            ping_pong.on_flight = true;
+                            ping_pong.in_flight = true;
                         }
                     },
                     None => return Poll::Pending,
@@ -287,13 +294,13 @@ fn prepare_response(
         _ => {}
     }
 
-    let _ = match size {
+    match size {
-        BodySize::None | BodySize::Stream => None,
+        BodySize::None | BodySize::Stream => {}
 
         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)
+            res.headers_mut().insert(CONTENT_LENGTH, HV_ZERO);
         }
 
         BodySize::Sized(len) => {
@@ -302,7 +309,7 @@ fn prepare_response(
             res.headers_mut().insert(
                 CONTENT_LENGTH,
                 HeaderValue::from_str(buf.format(*len)).unwrap(),
-            )
+            );
         }
     };
 

actix-http/src/h2/mod.rs

@@ -103,11 +103,9 @@ where
 
 #[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);
+    assert_impl_all!(Payload: Unpin, Send, Sync);
 }

actix-http/src/h2/service.rs

@@ -117,6 +117,7 @@ mod openssl {
         B: MessageBody + 'static,
     {
         /// Create OpenSSL based service.
+        #[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
         pub fn openssl(
             self,
             acceptor: SslAcceptor,
@@ -164,6 +165,7 @@ mod rustls {
         B: MessageBody + 'static,
     {
         /// Create Rustls based service.
+        #[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
         pub fn rustls(
             self,
             mut config: ServerConfig,

actix-http/src/header/map.rs

@@ -309,7 +309,7 @@ impl HeaderMap {
     pub fn get_all(&self, key: impl AsHeaderName) -> std::slice::Iter<'_, HeaderValue> {
         match self.get_value(key) {
             Some(value) => value.iter(),
-            None => (&[]).iter(),
+            None => [].iter(),
         }
     }
 

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

@@ -12,7 +12,7 @@ use crate::header::{Charset, HTTP_VALUE};
 /// - A character sequence representing the actual value (`value`), separated by single quotes.
 ///
 /// It is defined in [RFC 5987 §3.2](https://datatracker.ietf.org/doc/html/rfc5987#section-3.2).
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ExtendedValue {
     /// The character set that is used to encode the `value` to a string.
     pub charset: Charset,

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

@@ -147,7 +147,7 @@ mod tests {
 
     // copy of encoding from actix-web headers
     #[allow(clippy::enum_variant_names)] // allow Encoding prefix on EncodingExt
-    #[derive(Clone, PartialEq, Debug)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
     pub enum Encoding {
         Chunked,
         Brotli,

actix-http/src/lib.rs

@@ -25,6 +25,7 @@
 )]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub use ::http::{uri, uri::Uri};
 pub use ::http::{Method, StatusCode, Version};
@@ -39,6 +40,7 @@ pub mod error;
 mod extensions;
 pub mod h1;
 #[cfg(feature = "http2")]
+#[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
 pub mod h2;
 pub mod header;
 mod helpers;
@@ -53,6 +55,7 @@ mod responses;
 mod service;
 pub mod test;
 #[cfg(feature = "ws")]
+#[cfg_attr(docsrs, doc(cfg(feature = "ws")))]
 pub mod ws;
 
 pub use self::builder::HttpServiceBuilder;
@@ -69,6 +72,9 @@ 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;
+#[cfg(any(feature = "openssl", feature = "rustls"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "openssl", feature = "rustls"))))]
+pub use self::service::TlsAcceptorConfig;
 
 /// A major HTTP protocol version.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]

actix-http/src/message.rs

@@ -3,7 +3,7 @@ use std::{cell::RefCell, ops, rc::Rc};
 use bitflags::bitflags;
 
 /// Represents various types of connection
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ConnectionType {
     /// Close connection after response.
     Close,

actix-http/src/payload.rs

@@ -97,12 +97,10 @@ where
 
 #[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);
+    assert_not_impl_any!(Payload: Send, Sync);
 }

actix-http/src/requests/request.rs

@@ -113,14 +113,14 @@ impl<P> Request<P> {
     #[inline]
     /// Http message part of the request
     pub fn head(&self) -> &RequestHead {
-        &*self.head
+        &self.head
     }
 
     #[inline]
     #[doc(hidden)]
     /// Mutable reference to a HTTP message part of the request
     pub fn head_mut(&mut self) -> &mut RequestHead {
-        &mut *self.head
+        &mut self.head
     }
 
     /// Mutable reference to the message's headers.

actix-http/src/responses/head.rs

@@ -237,7 +237,7 @@ mod tests {
         .await;
 
         let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-        let _ = stream
+        stream
             .write_all(b"GET /camel HTTP/1.1\r\nConnection: Close\r\n\r\n")
             .unwrap();
         let mut data = vec![];
@@ -251,7 +251,7 @@ mod tests {
         assert!(memmem::find(&data, b"content-length").is_none());
 
         let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-        let _ = stream
+        stream
             .write_all(b"GET /lower HTTP/1.1\r\nConnection: Close\r\n\r\n")
             .unwrap();
         let mut data = vec![];

actix-http/src/responses/response.rs

@@ -83,13 +83,13 @@ impl<B> Response<B> {
     /// Returns a reference to the head of this response.
     #[inline]
     pub fn head(&self) -> &ResponseHead {
-        &*self.head
+        &self.head
     }
 
     /// Returns a mutable reference to the head of this response.
     #[inline]
     pub fn head_mut(&mut self) -> &mut ResponseHead {
-        &mut *self.head
+        &mut self.head
     }
 
     /// Returns the status code of this response.

actix-http/src/service.rs

@@ -181,6 +181,25 @@ where
     }
 }
 
+/// Configuration options used when accepting TLS connection.
+#[cfg(any(feature = "openssl", feature = "rustls"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "openssl", feature = "rustls"))))]
+#[derive(Debug, Default)]
+pub struct TlsAcceptorConfig {
+    pub(crate) handshake_timeout: Option<std::time::Duration>,
+}
+
+#[cfg(any(feature = "openssl", feature = "rustls"))]
+impl TlsAcceptorConfig {
+    /// Set TLS handshake timeout duration.
+    pub fn handshake_timeout(self, dur: std::time::Duration) -> Self {
+        Self {
+            handshake_timeout: Some(dur),
+            // ..self
+        }
+    }
+}
+
 #[cfg(feature = "openssl")]
 mod openssl {
     use actix_service::ServiceFactoryExt as _;
@@ -220,6 +239,7 @@ mod openssl {
         U::InitError: fmt::Debug,
     {
         /// Create OpenSSL based service.
+        #[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
         pub fn openssl(
             self,
             acceptor: SslAcceptor,
@@ -230,7 +250,29 @@ mod openssl {
             Error = TlsError<SslError, DispatchError>,
             InitError = (),
         > {
-            Acceptor::new(acceptor)
+            self.openssl_with_config(acceptor, TlsAcceptorConfig::default())
+        }
+
+        /// Create OpenSSL based service with custom TLS acceptor configuration.
+        #[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
+        pub fn openssl_with_config(
+            self,
+            acceptor: SslAcceptor,
+            tls_acceptor_config: TlsAcceptorConfig,
+        ) -> impl ServiceFactory<
+            TcpStream,
+            Config = (),
+            Response = (),
+            Error = TlsError<SslError, DispatchError>,
+            InitError = (),
+        > {
+            let mut acceptor = Acceptor::new(acceptor);
+
+            if let Some(handshake_timeout) = tls_acceptor_config.handshake_timeout {
+                acceptor.set_handshake_timeout(handshake_timeout);
+            }
+
+            acceptor
                 .map_init_err(|_| {
                     unreachable!("TLS acceptor service factory does not error on init")
                 })
@@ -292,9 +334,26 @@ mod rustls {
         U::InitError: fmt::Debug,
     {
         /// Create Rustls based service.
+        #[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
         pub fn rustls(
+            self,
+            config: ServerConfig,
+        ) -> impl ServiceFactory<
+            TcpStream,
+            Config = (),
+            Response = (),
+            Error = TlsError<io::Error, DispatchError>,
+            InitError = (),
+        > {
+            self.rustls_with_config(config, TlsAcceptorConfig::default())
+        }
+
+        /// Create Rustls based service with custom TLS acceptor configuration.
+        #[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
+        pub fn rustls_with_config(
             self,
             mut config: ServerConfig,
+            tls_acceptor_config: TlsAcceptorConfig,
         ) -> impl ServiceFactory<
             TcpStream,
             Config = (),
@@ -306,7 +365,13 @@ mod rustls {
             protos.extend_from_slice(&config.alpn_protocols);
             config.alpn_protocols = protos;
 
-            Acceptor::new(config)
+            let mut acceptor = Acceptor::new(config);
+
+            if let Some(handshake_timeout) = tls_acceptor_config.handshake_timeout {
+                acceptor.set_handshake_timeout(handshake_timeout);
+            }
+
+            acceptor
                 .map_init_err(|_| {
                     unreachable!("TLS acceptor service factory does not error on init")
                 })

actix-http/src/test.rs

@@ -19,29 +19,7 @@ use crate::{
     Request,
 };
 
-/// Test `Request` builder
+/// Test `Request` builder.
-///
-/// ```ignore
-/// # use http::{header, StatusCode};
-/// # use actix_web::*;
-/// use actix_web::test::TestRequest;
-///
-/// fn index(req: &HttpRequest) -> Response {
-///     if let Some(hdr) = req.headers().get(header::CONTENT_TYPE) {
-///         Response::Ok().into()
-///     } else {
-///         Response::BadRequest().into()
-///     }
-/// }
-///
-/// let resp = TestRequest::default().insert_header("content-type", "text/plain")
-///     .run(&index)
-///     .unwrap();
-/// assert_eq!(resp.status(), StatusCode::OK);
-///
-/// let resp = TestRequest::default().run(&index).unwrap();
-/// assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-/// ```
 pub struct TestRequest(Option<Inner>);
 
 struct Inner {

actix-http/src/ws/codec.rs

@@ -11,7 +11,7 @@ use super::{
 };
 
 /// A WebSocket message.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Message {
     /// Text message.
     Text(ByteString),
@@ -36,7 +36,7 @@ pub enum Message {
 }
 
 /// A WebSocket frame.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Frame {
     /// Text frame. Note that the codec does not validate UTF-8 encoding.
     Text(Bytes),
@@ -58,7 +58,7 @@ pub enum Frame {
 }
 
 /// A WebSocket continuation item.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Item {
     FirstText(Bytes),
     FirstBinary(Bytes),

actix-http/src/ws/frame.rs

@@ -17,7 +17,6 @@ impl Parser {
     fn parse_metadata(
         src: &[u8],
         server: bool,
-        max_size: usize,
     ) -> Result<Option<(usize, bool, OpCode, usize, Option<[u8; 4]>)>, ProtocolError> {
         let chunk_len = src.len();
 
@@ -60,20 +59,12 @@ impl Parser {
                 return Ok(None);
             }
             let len = u64::from_be_bytes(TryFrom::try_from(&src[idx..idx + 8]).unwrap());
-            if len > max_size as u64 {
-                return Err(ProtocolError::Overflow);
-            }
             idx += 8;
             len as usize
         } else {
             len as usize
         };
 
-        // check for max allowed size
-        if length > max_size {
-            return Err(ProtocolError::Overflow);
-        }
-
         let mask = if server {
             if chunk_len < idx + 4 {
                 return Ok(None);
@@ -98,8 +89,7 @@ impl Parser {
         max_size: usize,
     ) -> Result<Option<(bool, OpCode, Option<BytesMut>)>, ProtocolError> {
         // try to parse ws frame metadata
-        let (idx, finished, opcode, length, mask) =
+        let (idx, finished, opcode, length, mask) = match Parser::parse_metadata(src, server)? {
-            match Parser::parse_metadata(src, server, max_size)? {
             None => return Ok(None),
             Some(res) => res,
         };
@@ -112,6 +102,13 @@ impl Parser {
         // remove prefix
         src.advance(idx);
 
+        // check for max allowed size
+        if length > max_size {
+            // drop the payload
+            src.advance(length);
+            return Err(ProtocolError::Overflow);
+        }
+
         // no need for body
         if length == 0 {
             return Ok(Some((finished, opcode, None)));
@@ -316,7 +313,7 @@ mod tests {
     #[test]
     fn test_parse_frame_no_mask() {
         let mut buf = BytesMut::from(&[0b0000_0001u8, 0b0000_0001u8][..]);
-        buf.extend(&[1u8]);
+        buf.extend([1u8]);
 
         assert!(Parser::parse(&mut buf, true, 1024).is_err());
 
@@ -329,7 +326,7 @@ mod tests {
     #[test]
     fn test_parse_frame_max_size() {
         let mut buf = BytesMut::from(&[0b0000_0001u8, 0b0000_0010u8][..]);
-        buf.extend(&[1u8, 1u8]);
+        buf.extend([1u8, 1u8]);
 
         assert!(Parser::parse(&mut buf, true, 1).is_err());
 
@@ -339,6 +336,30 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_parse_frame_max_size_recoverability() {
+        let mut buf = BytesMut::new();
+        // The first text frame with length == 2, payload doesn't matter.
+        buf.extend([0b0000_0001u8, 0b0000_0010u8, 0b0000_0000u8, 0b0000_0000u8]);
+        // Next binary frame with length == 2 and payload == `[0x1111_1111u8, 0x1111_1111u8]`.
+        buf.extend([0b0000_0010u8, 0b0000_0010u8, 0b1111_1111u8, 0b1111_1111u8]);
+
+        assert_eq!(buf.len(), 8);
+        assert!(matches!(
+            Parser::parse(&mut buf, false, 1),
+            Err(ProtocolError::Overflow)
+        ));
+        assert_eq!(buf.len(), 4);
+        let frame = extract(Parser::parse(&mut buf, false, 2));
+        assert!(!frame.finished);
+        assert_eq!(frame.opcode, OpCode::Binary);
+        assert_eq!(
+            frame.payload,
+            Bytes::from(vec![0b1111_1111u8, 0b1111_1111u8])
+        );
+        assert_eq!(buf.len(), 0);
+    }
+
     #[test]
     fn test_ping_frame() {
         let mut buf = BytesMut::new();

actix-http/src/ws/mod.rs

@@ -67,7 +67,7 @@ pub enum ProtocolError {
 }
 
 /// WebSocket handshake errors
-#[derive(Debug, Clone, Copy, PartialEq, Display, Error)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Display, Error)]
 pub enum HandshakeError {
     /// Only get method is allowed.
     #[display(fmt = "Method not allowed.")]

actix-http/src/ws/proto.rs

@@ -244,7 +244,7 @@ pub fn hash_key(key: &[u8]) -> [u8; 28] {
     };
 
     let mut hash_b64 = [0; 28];
-    let n = base64::encode_config_slice(&hash, base64::STANDARD, &mut hash_b64);
+    let n = base64::encode_config_slice(hash, base64::STANDARD, &mut hash_b64);
     assert_eq!(n, 28);
 
     hash_b64

actix-http/tests/test_openssl.rs

@@ -2,13 +2,13 @@
 
 extern crate tls_openssl as openssl;
 
-use std::{convert::Infallible, io};
+use std::{convert::Infallible, io, time::Duration};
 
 use actix_http::{
     body::{BodyStream, BoxBody, SizedStream},
     error::PayloadError,
     header::{self, HeaderValue},
-    Error, HttpService, Method, Request, Response, StatusCode, Version,
+    Error, HttpService, Method, Request, Response, StatusCode, TlsAcceptorConfig, Version,
 };
 use actix_http_test::test_server;
 use actix_service::{fn_service, ServiceFactoryExt};
@@ -89,7 +89,10 @@ async fn h2_1() -> io::Result<()> {
                 assert_eq!(req.version(), Version::HTTP_2);
                 ok::<_, Error>(Response::ok())
             })
-            .openssl(tls_config())
+            .openssl_with_config(
+                tls_config(),
+                TlsAcceptorConfig::default().handshake_timeout(Duration::from_secs(5)),
+            )
             .map_err(|_| ())
     })
     .await;

actix-http/tests/test_rustls.rs

@@ -8,13 +8,14 @@ use std::{
     net::{SocketAddr, TcpStream as StdTcpStream},
     sync::Arc,
     task::Poll,
+    time::Duration,
 };
 
 use actix_http::{
     body::{BodyStream, BoxBody, SizedStream},
     error::PayloadError,
     header::{self, HeaderName, HeaderValue},
-    Error, HttpService, Method, Request, Response, StatusCode, Version,
+    Error, HttpService, Method, Request, Response, StatusCode, TlsAcceptorConfig, Version,
 };
 use actix_http_test::test_server;
 use actix_rt::pin;
@@ -40,7 +41,7 @@ where
         let body = stream.as_mut();
 
         match ready!(body.poll_next(cx)) {
-            Some(Ok(bytes)) => buf.extend_from_slice(&*bytes),
+            Some(Ok(bytes)) => buf.extend_from_slice(&bytes),
             None => return Poll::Ready(Ok(())),
             Some(Err(err)) => return Poll::Ready(Err(err)),
         }
@@ -160,7 +161,10 @@ async fn h2_1() -> io::Result<()> {
                 assert_eq!(req.version(), Version::HTTP_2);
                 ok::<_, Error>(Response::ok())
             })
-            .rustls(tls_config())
+            .rustls_with_config(
+                tls_config(),
+                TlsAcceptorConfig::default().handshake_timeout(Duration::from_secs(5)),
+            )
     })
     .await;
 

actix-multipart/CHANGES.md

@@ -1,6 +1,10 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.
+- `Field::content_type()` now returns `Option<&mime::Mime>` [#2880]
+
+[#2880]: https://github.com/actix/actix-web/pull/2880
 
 
 ## 0.4.0 - 2022-02-25

actix-multipart/Cargo.toml

@@ -15,7 +15,7 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-utils = "3"
-actix-web = { version = "4.0.0", default-features = false }
+actix-web = { version = "4", default-features = false }
 
 bytes = "1"
 derive_more = "0.99.5"
@@ -28,7 +28,7 @@ twoway = "0.2"
 
 [dev-dependencies]
 actix-rt = "2.2"
-actix-http = "3.0.0"
+actix-http = "3"
 futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
 tokio = { version = "1.8.4", features = ["sync"] }
 tokio-stream = "0.1"

actix-multipart/README.md

@@ -4,7 +4,7 @@
 
 [![crates.io](https://img.shields.io/crates/v/actix-multipart?label=latest)](https://crates.io/crates/actix-multipart)
 [![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.4.0)](https://docs.rs/actix-multipart/0.4.0)
-[![Version](https://img.shields.io/badge/rustc-1.54+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.54.0.html)
+![Version](https://img.shields.io/badge/rustc-1.59+-ab6000.svg)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-multipart.svg)
 <br />
 [![dependency status](https://deps.rs/crate/actix-multipart/0.4.0/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0)

actix-multipart/src/server.rs

@@ -289,10 +289,8 @@ impl InnerMultipart {
                 match self.state {
                     // read until first boundary
                     InnerState::FirstBoundary => {
-                        match InnerMultipart::skip_until_boundary(
+                        match InnerMultipart::skip_until_boundary(&mut payload, &self.boundary)?
-                            &mut *payload,
+                        {
-                            &self.boundary,
-                        )? {
                             Some(eof) => {
                                 if eof {
                                     self.state = InnerState::Eof;
@@ -306,7 +304,7 @@ impl InnerMultipart {
                     }
                     // read boundary
                     InnerState::Boundary => {
-                        match InnerMultipart::read_boundary(&mut *payload, &self.boundary)? {
+                        match InnerMultipart::read_boundary(&mut payload, &self.boundary)? {
                             None => return Poll::Pending,
                             Some(eof) => {
                                 if eof {
@@ -323,7 +321,7 @@ impl InnerMultipart {
 
                 // read field headers for next field
                 if self.state == InnerState::Headers {
-                    if let Some(headers) = InnerMultipart::read_headers(&mut *payload)? {
+                    if let Some(headers) = InnerMultipart::read_headers(&mut payload)? {
                         self.state = InnerState::Boundary;
                         headers
                     } else {
@@ -361,18 +359,19 @@ impl InnerMultipart {
                 return Poll::Ready(Some(Err(MultipartError::NoContentDisposition)));
             };
 
-            let ct: mime::Mime = headers
+            let ct: Option<mime::Mime> = headers
                 .get(&header::CONTENT_TYPE)
                 .and_then(|ct| ct.to_str().ok())
-                .and_then(|ct| ct.parse().ok())
+                .and_then(|ct| ct.parse().ok());
-                .unwrap_or(mime::APPLICATION_OCTET_STREAM);
 
             self.state = InnerState::Boundary;
 
             // nested multipart stream is not supported
-            if ct.type_() == mime::MULTIPART {
+            if let Some(mime) = &ct {
+                if mime.type_() == mime::MULTIPART {
                     return Poll::Ready(Some(Err(MultipartError::Nested)));
                 }
+            }
 
             let field =
                 InnerField::new_in_rc(self.payload.clone(), self.boundary.clone(), &headers)?;
@@ -399,7 +398,7 @@ impl Drop for InnerMultipart {
 
 /// A single field in a multipart stream
 pub struct Field {
-    ct: mime::Mime,
+    ct: Option<mime::Mime>,
     cd: ContentDisposition,
     headers: HeaderMap,
     inner: Rc<RefCell<InnerField>>,
@@ -410,7 +409,7 @@ impl Field {
     fn new(
         safety: Safety,
         headers: HeaderMap,
-        ct: mime::Mime,
+        ct: Option<mime::Mime>,
         cd: ContentDisposition,
         inner: Rc<RefCell<InnerField>>,
     ) -> Self {
@@ -428,9 +427,13 @@ impl Field {
         &self.headers
     }
 
-    /// Returns a reference to the field's content (mime) type.
+    /// Returns a reference to the field's content (mime) type, if it is supplied by the client.
-    pub fn content_type(&self) -> &mime::Mime {
+    ///
-        &self.ct
+    /// According to [RFC 7578](https://www.rfc-editor.org/rfc/rfc7578#section-4.4), if it is not
+    /// present, it should default to "text/plain". Note it is the responsibility of the client to
+    /// provide the appropriate content type, there is no attempt to validate this by the server.
+    pub fn content_type(&self) -> Option<&mime::Mime> {
+        self.ct.as_ref()
     }
 
     /// Returns the field's Content-Disposition.
@@ -482,7 +485,11 @@ impl Stream for Field {
 
 impl fmt::Debug for Field {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(f, "\nField: {}", self.ct)?;
+        if let Some(ct) = &self.ct {
+            writeln!(f, "\nField: {}", ct)?;
+        } else {
+            writeln!(f, "\nField:")?;
+        }
         writeln!(f, "  boundary: {}", self.inner.borrow().boundary)?;
         writeln!(f, "  headers:")?;
         for (key, val) in self.headers.iter() {
@@ -643,9 +650,9 @@ impl InnerField {
         let result = if let Some(mut payload) = self.payload.as_ref().unwrap().get_mut(s) {
             if !self.eof {
                 let res = if let Some(ref mut len) = self.length {
-                    InnerField::read_len(&mut *payload, len)
+                    InnerField::read_len(&mut payload, len)
                 } else {
-                    InnerField::read_stream(&mut *payload, &self.boundary)
+                    InnerField::read_stream(&mut payload, &self.boundary)
                 };
 
                 match res {
@@ -1024,8 +1031,8 @@ mod tests {
                 assert_eq!(cd.disposition, DispositionType::FormData);
                 assert_eq!(cd.parameters[0], DispositionParam::Name("file".into()));
 
-                assert_eq!(field.content_type().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
-                assert_eq!(field.content_type().subtype(), mime::PLAIN);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
 
                 match field.next().await.unwrap() {
                     Ok(chunk) => assert_eq!(chunk, "test"),
@@ -1041,8 +1048,8 @@ mod tests {
 
         match multipart.next().await.unwrap() {
             Ok(mut field) => {
-                assert_eq!(field.content_type().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
-                assert_eq!(field.content_type().subtype(), mime::PLAIN);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
 
                 match field.next().await {
                     Some(Ok(chunk)) => assert_eq!(chunk, "data"),
@@ -1086,8 +1093,8 @@ mod tests {
                 assert_eq!(cd.disposition, DispositionType::FormData);
                 assert_eq!(cd.parameters[0], DispositionParam::Name("file".into()));
 
-                assert_eq!(field.content_type().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
-                assert_eq!(field.content_type().subtype(), mime::PLAIN);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
 
                 assert_eq!(get_whole_field(&mut field).await, "test");
             }
@@ -1096,8 +1103,8 @@ mod tests {
 
         match multipart.next().await {
             Some(Ok(mut field)) => {
-                assert_eq!(field.content_type().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
-                assert_eq!(field.content_type().subtype(), mime::PLAIN);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
 
                 assert_eq!(get_whole_field(&mut field).await, "data");
             }

actix-router/CHANGES.md

@@ -1,6 +1,13 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+
+
+## 0.5.1 - 2022-09-19
+- Correct typo in error string for `i32` deserialization. [#2876]
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.
+
+[#2876]: https://github.com/actix/actix-web/pull/2876
 
 
 ## 0.5.0 - 2022-02-22

actix-router/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-router"
-version = "0.5.0"
+version = "0.5.1"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Ali MJ Al-Nasrawy <alimjalnasrawy@gmail.com>",
@@ -21,18 +21,21 @@ default = ["http"]
 
 [dependencies]
 bytestring = ">=0.1.5, <2"
-firestorm = "0.5"
+http = { version = "0.2.5", optional = true }
-http = { version = "0.2.3", optional = true }
 regex = "1.5"
 serde = "1"
 tracing = { version = "0.1.30", default-features = false, features = ["log"] }
 
 [dev-dependencies]
 criterion = { version = "0.3", features = ["html_reports"] }
-firestorm = { version = "0.5", features = ["enable_system_time"] }
 http = "0.2.5"
 serde = { version = "1", features = ["derive"] }
+percent-encoding = "2.1"
 
 [[bench]]
 name = "router"
 harness = false
+
+[[bench]]
+name = "quoter"
+harness = false

actix-router/benches/quoter.rs

@@ -0,0 +1,52 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+use std::borrow::Cow;
+
+fn compare_quoters(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Compare Quoters");
+
+    let quoter = actix_router::Quoter::new(b"", b"");
+    let path_quoted = (0..=0x7f)
+        .map(|c| format!("%{:02X}", c))
+        .collect::<String>();
+    let path_unquoted = ('\u{00}'..='\u{7f}').collect::<String>();
+
+    group.bench_function("quoter_unquoted", |b| {
+        b.iter(|| {
+            for _ in 0..10 {
+                black_box(quoter.requote(path_unquoted.as_bytes()));
+            }
+        });
+    });
+
+    group.bench_function("percent_encode_unquoted", |b| {
+        b.iter(|| {
+            for _ in 0..10 {
+                let decode = percent_encoding::percent_decode(path_unquoted.as_bytes());
+                black_box(Into::<Cow<'_, [u8]>>::into(decode));
+            }
+        });
+    });
+
+    group.bench_function("quoter_quoted", |b| {
+        b.iter(|| {
+            for _ in 0..10 {
+                black_box(quoter.requote(path_quoted.as_bytes()));
+            }
+        });
+    });
+
+    group.bench_function("percent_encode_quoted", |b| {
+        b.iter(|| {
+            for _ in 0..10 {
+                let decode = percent_encoding::percent_decode(path_quoted.as_bytes());
+                black_box(Into::<Cow<'_, [u8]>>::into(decode));
+            }
+        });
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, compare_quoters);
+criterion_main!(benches);

actix-router/examples/flamegraph.rs

@@ -1,169 +0,0 @@
-macro_rules! register {
-    (brackets) => {{
-        register!(finish => "{p1}", "{p2}", "{p3}", "{p4}")
-    }};
-    (finish => $p1:literal, $p2:literal, $p3:literal, $p4:literal) => {{
-        let arr = [
-            concat!("/authorizations"),
-            concat!("/authorizations/", $p1),
-            concat!("/applications/", $p1, "/tokens/", $p2),
-            concat!("/events"),
-            concat!("/repos/", $p1, "/", $p2, "/events"),
-            concat!("/networks/", $p1, "/", $p2, "/events"),
-            concat!("/orgs/", $p1, "/events"),
-            concat!("/users/", $p1, "/received_events"),
-            concat!("/users/", $p1, "/received_events/public"),
-            concat!("/users/", $p1, "/events"),
-            concat!("/users/", $p1, "/events/public"),
-            concat!("/users/", $p1, "/events/orgs/", $p2),
-            concat!("/feeds"),
-            concat!("/notifications"),
-            concat!("/repos/", $p1, "/", $p2, "/notifications"),
-            concat!("/notifications/threads/", $p1),
-            concat!("/notifications/threads/", $p1, "/subscription"),
-            concat!("/repos/", $p1, "/", $p2, "/stargazers"),
-            concat!("/users/", $p1, "/starred"),
-            concat!("/user/starred"),
-            concat!("/user/starred/", $p1, "/", $p2),
-            concat!("/repos/", $p1, "/", $p2, "/subscribers"),
-            concat!("/users/", $p1, "/subscriptions"),
-            concat!("/user/subscriptions"),
-            concat!("/repos/", $p1, "/", $p2, "/subscription"),
-            concat!("/user/subscriptions/", $p1, "/", $p2),
-            concat!("/users/", $p1, "/gists"),
-            concat!("/gists"),
-            concat!("/gists/", $p1),
-            concat!("/gists/", $p1, "/star"),
-            concat!("/repos/", $p1, "/", $p2, "/git/blobs/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/git/commits/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/git/refs"),
-            concat!("/repos/", $p1, "/", $p2, "/git/tags/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/git/trees/", $p3),
-            concat!("/issues"),
-            concat!("/user/issues"),
-            concat!("/orgs/", $p1, "/issues"),
-            concat!("/repos/", $p1, "/", $p2, "/issues"),
-            concat!("/repos/", $p1, "/", $p2, "/issues/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/assignees"),
-            concat!("/repos/", $p1, "/", $p2, "/assignees/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/issues/", $p3, "/comments"),
-            concat!("/repos/", $p1, "/", $p2, "/issues/", $p3, "/events"),
-            concat!("/repos/", $p1, "/", $p2, "/labels"),
-            concat!("/repos/", $p1, "/", $p2, "/labels/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/issues/", $p3, "/labels"),
-            concat!("/repos/", $p1, "/", $p2, "/milestones/", $p3, "/labels"),
-            concat!("/repos/", $p1, "/", $p2, "/milestones/"),
-            concat!("/repos/", $p1, "/", $p2, "/milestones/", $p3),
-            concat!("/emojis"),
-            concat!("/gitignore/templates"),
-            concat!("/gitignore/templates/", $p1),
-            concat!("/meta"),
-            concat!("/rate_limit"),
-            concat!("/users/", $p1, "/orgs"),
-            concat!("/user/orgs"),
-            concat!("/orgs/", $p1),
-            concat!("/orgs/", $p1, "/members"),
-            concat!("/orgs/", $p1, "/members", $p2),
-            concat!("/orgs/", $p1, "/public_members"),
-            concat!("/orgs/", $p1, "/public_members/", $p2),
-            concat!("/orgs/", $p1, "/teams"),
-            concat!("/teams/", $p1),
-            concat!("/teams/", $p1, "/members"),
-            concat!("/teams/", $p1, "/members", $p2),
-            concat!("/teams/", $p1, "/repos"),
-            concat!("/teams/", $p1, "/repos/", $p2, "/", $p3),
-            concat!("/user/teams"),
-            concat!("/repos/", $p1, "/", $p2, "/pulls"),
-            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3, "/commits"),
-            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3, "/files"),
-            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3, "/merge"),
-            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3, "/comments"),
-            concat!("/user/repos"),
-            concat!("/users/", $p1, "/repos"),
-            concat!("/orgs/", $p1, "/repos"),
-            concat!("/repositories"),
-            concat!("/repos/", $p1, "/", $p2),
-            concat!("/repos/", $p1, "/", $p2, "/contributors"),
-            concat!("/repos/", $p1, "/", $p2, "/languages"),
-            concat!("/repos/", $p1, "/", $p2, "/teams"),
-            concat!("/repos/", $p1, "/", $p2, "/tags"),
-            concat!("/repos/", $p1, "/", $p2, "/branches"),
-            concat!("/repos/", $p1, "/", $p2, "/branches/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/collaborators"),
-            concat!("/repos/", $p1, "/", $p2, "/collaborators/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/comments"),
-            concat!("/repos/", $p1, "/", $p2, "/commits/", $p3, "/comments"),
-            concat!("/repos/", $p1, "/", $p2, "/commits"),
-            concat!("/repos/", $p1, "/", $p2, "/commits/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/readme"),
-            concat!("/repos/", $p1, "/", $p2, "/keys"),
-            concat!("/repos/", $p1, "/", $p2, "/keys", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/downloads"),
-            concat!("/repos/", $p1, "/", $p2, "/downloads", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/forks"),
-            concat!("/repos/", $p1, "/", $p2, "/hooks"),
-            concat!("/repos/", $p1, "/", $p2, "/hooks", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/releases"),
-            concat!("/repos/", $p1, "/", $p2, "/releases/", $p3),
-            concat!("/repos/", $p1, "/", $p2, "/releases/", $p3, "/assets"),
-            concat!("/repos/", $p1, "/", $p2, "/stats/contributors"),
-            concat!("/repos/", $p1, "/", $p2, "/stats/commit_activity"),
-            concat!("/repos/", $p1, "/", $p2, "/stats/code_frequency"),
-            concat!("/repos/", $p1, "/", $p2, "/stats/participation"),
-            concat!("/repos/", $p1, "/", $p2, "/stats/punch_card"),
-            concat!("/repos/", $p1, "/", $p2, "/statuses/", $p3),
-            concat!("/search/repositories"),
-            concat!("/search/code"),
-            concat!("/search/issues"),
-            concat!("/search/users"),
-            concat!("/legacy/issues/search/", $p1, "/", $p2, "/", $p3, "/", $p4),
-            concat!("/legacy/repos/search/", $p1),
-            concat!("/legacy/user/search/", $p1),
-            concat!("/legacy/user/email/", $p1),
-            concat!("/users/", $p1),
-            concat!("/user"),
-            concat!("/users"),
-            concat!("/user/emails"),
-            concat!("/users/", $p1, "/followers"),
-            concat!("/user/followers"),
-            concat!("/users/", $p1, "/following"),
-            concat!("/user/following"),
-            concat!("/user/following/", $p1),
-            concat!("/users/", $p1, "/following", $p2),
-            concat!("/users/", $p1, "/keys"),
-            concat!("/user/keys"),
-            concat!("/user/keys/", $p1),
-        ];
-
-        arr.to_vec()
-    }};
-}
-
-static PATHS: [&str; 5] = [
-    "/authorizations",
-    "/user/repos",
-    "/repos/rust-lang/rust/stargazers",
-    "/orgs/rust-lang/public_members/nikomatsakis",
-    "/repos/rust-lang/rust/releases/1.51.0",
-];
-
-fn main() {
-    let mut router = actix_router::Router::<bool>::build();
-
-    for route in register!(brackets) {
-        router.path(route, true);
-    }
-
-    let actix = router.finish();
-
-    if firestorm::enabled() {
-        firestorm::bench("target", || {
-            for &route in &PATHS {
-                let mut path = actix_router::Path::new(route);
-                actix.recognize(&mut path).unwrap();
-            }
-        })
-        .unwrap();
-    }
-}

actix-router/src/de.rs

@@ -7,7 +7,7 @@ use crate::path::{Path, PathIter};
 use crate::{Quoter, ResourcePath};
 
 thread_local! {
-    static FULL_QUOTER: Quoter = Quoter::new(b"+/%", b"");
+    static FULL_QUOTER: Quoter = Quoter::new(b"", b"");
 }
 
 macro_rules! unsupported_type {
@@ -293,7 +293,7 @@ impl<'de> Deserializer<'de> for Value<'de> {
     parse_value!(deserialize_bool, visit_bool, "bool");
     parse_value!(deserialize_i8, visit_i8, "i8");
     parse_value!(deserialize_i16, visit_i16, "i16");
-    parse_value!(deserialize_i32, visit_i32, "i16");
+    parse_value!(deserialize_i32, visit_i32, "i32");
     parse_value!(deserialize_i64, visit_i64, "i64");
     parse_value!(deserialize_u8, visit_u8, "u8");
     parse_value!(deserialize_u16, visit_u16, "u16");

actix-router/src/path.rs

@@ -1,7 +1,6 @@
 use std::borrow::Cow;
 use std::ops::{DerefMut, Index};
 
-use firestorm::profile_method;
 use serde::de;
 
 use crate::{de::PathDeserializer, Resource, ResourcePath};
@@ -52,7 +51,6 @@ impl<T: ResourcePath> Path<T> {
     /// Returns full path as a string.
     #[inline]
     pub fn as_str(&self) -> &str {
-        profile_method!(as_str);
         self.path.path()
     }
 
@@ -61,7 +59,6 @@ impl<T: ResourcePath> Path<T> {
     /// Returns empty string if no more is to be processed.
     #[inline]
     pub fn unprocessed(&self) -> &str {
-        profile_method!(unprocessed);
         // clamp skip to path length
         let skip = (self.skip as usize).min(self.as_str().len());
         &self.path.path()[skip..]
@@ -72,8 +69,6 @@ impl<T: ResourcePath> Path<T> {
     #[deprecated(since = "0.6.0", note = "Use `.as_str()` or `.unprocessed()`.")]
     #[inline]
     pub fn path(&self) -> &str {
-        profile_method!(path);
-
         let skip = self.skip as usize;
         let path = self.path.path();
         if skip <= path.len() {
@@ -86,8 +81,6 @@ impl<T: ResourcePath> Path<T> {
     /// Set new path.
     #[inline]
     pub fn set(&mut self, path: T) {
-        profile_method!(set);
-
         self.skip = 0;
         self.path = path;
         self.segments.clear();
@@ -96,8 +89,6 @@ impl<T: ResourcePath> Path<T> {
     /// Reset state.
     #[inline]
     pub fn reset(&mut self) {
-        profile_method!(reset);
-
         self.skip = 0;
         self.segments.clear();
     }
@@ -105,13 +96,10 @@ impl<T: ResourcePath> Path<T> {
     /// Skip first `n` chars in path.
     #[inline]
     pub fn skip(&mut self, n: u16) {
-        profile_method!(skip);
         self.skip += n;
     }
 
     pub(crate) fn add(&mut self, name: impl Into<Cow<'static, str>>, value: PathItem) {
-        profile_method!(add);
-
         match value {
             PathItem::Static(s) => self.segments.push((name.into(), PathItem::Static(s))),
             PathItem::Segment(begin, end) => self.segments.push((
@@ -127,8 +115,6 @@ impl<T: ResourcePath> Path<T> {
         name: impl Into<Cow<'static, str>>,
         value: impl Into<Cow<'static, str>>,
     ) {
-        profile_method!(add_static);
-
         self.segments
             .push((name.into(), PathItem::Static(value.into())));
     }
@@ -147,8 +133,6 @@ impl<T: ResourcePath> Path<T> {
 
     /// Get matched parameter by name without type conversion
     pub fn get(&self, name: &str) -> Option<&str> {
-        profile_method!(get);
-
         for (seg_name, val) in self.segments.iter() {
             if name == seg_name {
                 return match val {
@@ -167,8 +151,6 @@ impl<T: ResourcePath> Path<T> {
     ///
     /// If keyed parameter is not available empty string is used as default value.
     pub fn query(&self, key: &str) -> &str {
-        profile_method!(query);
-
         if let Some(s) = self.get(key) {
             s
         } else {
@@ -186,7 +168,6 @@ impl<T: ResourcePath> Path<T> {
 
     /// Try to deserialize matching parameters to a specified type `U`
     pub fn load<'de, U: serde::Deserialize<'de>>(&'de self) -> Result<U, de::value::Error> {
-        profile_method!(load);
         de::Deserialize::deserialize(PathDeserializer::new(self))
     }
 }
@@ -261,6 +242,7 @@ mod tests {
 
     use super::*;
 
+    #[allow(clippy::needless_borrow)]
     #[test]
     fn deref_impls() {
         let mut foo = Path::new("/foo");

actix-router/src/quoter.rs

@@ -1,132 +1,89 @@
-#[allow(dead_code)]
+/// Partial percent-decoding.
-const GEN_DELIMS: &[u8] = b":/?#[]@";
+///
-
+/// Performs percent-decoding on a slice but can selectively skip decoding certain sequences.
-#[allow(dead_code)]
+///
-const SUB_DELIMS_WITHOUT_QS: &[u8] = b"!$'()*,";
+/// # Examples
-
+/// ```
-#[allow(dead_code)]
+/// # use actix_router::Quoter;
-const SUB_DELIMS: &[u8] = b"!$'()*,+?=;";
+/// // + is set as a protected character and will not be decoded...
-
+/// let q = Quoter::new(&[], b"+");
-#[allow(dead_code)]
+///
-const RESERVED: &[u8] = b":/?#[]@!$'()*,+?=;";
+/// // ...but the other encoded characters (like the hyphen below) will.
-
+/// assert_eq!(q.requote(b"/a%2Db%2Bc").unwrap(), b"/a-b%2Bc");
-#[allow(dead_code)]
+/// ```
-const UNRESERVED: &[u8] = b"abcdefghijklmnopqrstuvwxyz
-    ABCDEFGHIJKLMNOPQRSTUVWXYZ
-    1234567890
-    -._~";
-
-const ALLOWED: &[u8] = b"abcdefghijklmnopqrstuvwxyz
-    ABCDEFGHIJKLMNOPQRSTUVWXYZ
-    1234567890
-    -._~
-    !$'()*,";
-
-const QS: &[u8] = b"+&=;b";
-
-/// A quoter
 pub struct Quoter {
-    /// Simple bit-map of safe values in the 0-127 ASCII range.
-    safe_table: [u8; 16],
-
     /// Simple bit-map of protected values in the 0-127 ASCII range.
-    protected_table: [u8; 16],
+    protected_table: AsciiBitmap,
 }
 
 impl Quoter {
-    pub fn new(safe: &[u8], protected: &[u8]) -> Quoter {
+    /// Constructs a new `Quoter` instance given a set of protected ASCII bytes.
-        let mut quoter = Quoter {
+    ///
-            safe_table: [0; 16],
+    /// The first argument is ignored but is kept for backward compatibility.
-            protected_table: [0; 16],
+    ///
-        };
+    /// # Panics
-
+    /// Panics if any of the `protected` bytes are not in the 0-127 ASCII range.
-        // prepare safe table
+    pub fn new(_: &[u8], protected: &[u8]) -> Quoter {
-        for ch in 0..128 {
+        let mut protected_table = AsciiBitmap::default();
-            if ALLOWED.contains(&ch) {
-                set_bit(&mut quoter.safe_table, ch);
-            }
-
-            if QS.contains(&ch) {
-                set_bit(&mut quoter.safe_table, ch);
-            }
-        }
-
-        for &ch in safe {
-            set_bit(&mut quoter.safe_table, ch)
-        }
 
         // prepare protected table
         for &ch in protected {
-            set_bit(&mut quoter.safe_table, ch);
+            protected_table.set_bit(ch);
-            set_bit(&mut quoter.protected_table, ch);
         }
 
-        quoter
+        Quoter { protected_table }
     }
 
-    /// Decodes safe percent-encoded sequences from `val`.
+    /// Decodes the next escape sequence, if any, and advances `val`.
+    #[inline(always)]
+    fn decode_next<'a>(&self, val: &mut &'a [u8]) -> Option<(&'a [u8], u8)> {
+        for i in 0..val.len() {
+            if let (prev, [b'%', p1, p2, rem @ ..]) = val.split_at(i) {
+                if let Some(ch) = hex_pair_to_char(*p1, *p2)
+                    // ignore protected ascii bytes
+                    .filter(|&ch| !(ch < 128 && self.protected_table.bit_at(ch)))
+                {
+                    *val = rem;
+                    return Some((prev, ch));
+                }
+            }
+        }
+
+        None
+    }
+
+    /// Partially percent-decodes the given bytes.
     ///
-    /// Returns `None` when no modification to the original byte string was required.
+    /// Escape sequences of the protected set are *not* decoded.
     ///
-    /// Non-ASCII bytes are accepted as valid input.
+    /// Returns `None` when no modification to the original bytes was required.
     ///
-    /// Behavior for invalid/incomplete percent-encoding sequences is unspecified and may include
+    /// Invalid/incomplete percent-encoding sequences are passed unmodified.
-    /// removing the invalid sequence from the output or passing it as-is.
     pub fn requote(&self, val: &[u8]) -> Option<Vec<u8>> {
-        let mut has_pct = 0;
+        let mut remaining = val;
-        let mut pct = [b'%', 0, 0];
-        let mut idx = 0;
-        let mut cloned: Option<Vec<u8>> = None;
 
-        let len = val.len();
+        // early return indicates that no percent-encoded sequences exist and we can skip allocation
+        let (pre, decoded_char) = self.decode_next(&mut remaining)?;
 
-        while idx < len {
+        // decoded output will always be shorter than the input
-            let ch = val[idx];
+        let mut decoded = Vec::<u8>::with_capacity(val.len());
 
-            if has_pct != 0 {
+        // push first segment and decoded char
-                pct[has_pct] = val[idx];
+        decoded.extend_from_slice(pre);
-                has_pct += 1;
+        decoded.push(decoded_char);
 
-                if has_pct == 3 {
+        // decode and push rest of segments and decoded chars
-                    has_pct = 0;
+        while let Some((prev, ch)) = self.decode_next(&mut remaining) {
-                    let buf = cloned.as_mut().unwrap();
+            // this ugly conditional achieves +50% perf in cases where this is a tight loop.
-
+            if !prev.is_empty() {
-                    if let Some(ch) = hex_pair_to_char(pct[1], pct[2]) {
+                decoded.extend_from_slice(prev);
-                        if ch < 128 {
+            }
-                            if bit_at(&self.protected_table, ch) {
+            decoded.push(ch);
-                                buf.extend_from_slice(&pct);
-                                idx += 1;
-                                continue;
         }
 
-                            if bit_at(&self.safe_table, ch) {
+        decoded.extend_from_slice(remaining);
-                                buf.push(ch);
-                                idx += 1;
-                                continue;
-                            }
-                        }
 
-                        buf.push(ch);
+        Some(decoded)
-                    } else {
-                        buf.extend_from_slice(&pct[..]);
-                    }
-                }
-            } else if ch == b'%' {
-                has_pct = 1;
-
-                if cloned.is_none() {
-                    let mut c = Vec::with_capacity(len);
-                    c.extend_from_slice(&val[..idx]);
-                    cloned = Some(c);
-                }
-            } else if let Some(ref mut cloned) = cloned {
-                cloned.push(ch)
-            }
-
-            idx += 1;
-        }
-
-        cloned
     }
 
     pub(crate) fn requote_str_lossy(&self, val: &str) -> Option<String> {
@@ -135,24 +92,6 @@ impl Quoter {
     }
 }
 
-/// Converts an ASCII character in the hex-encoded set (`0-9`, `A-F`, `a-f`) to its integer
-/// representation from `0x0`–`0xF`.
-///
-/// - `0x30 ('0') => 0x0`
-/// - `0x39 ('9') => 0x9`
-/// - `0x41 ('a') => 0xA`
-/// - `0x61 ('A') => 0xA`
-/// - `0x46 ('f') => 0xF`
-/// - `0x66 ('F') => 0xF`
-fn from_ascii_hex(v: u8) -> Option<u8> {
-    match v {
-        b'0'..=b'9' => Some(v - 0x30),      // ord('0') == 0x30
-        b'A'..=b'F' => Some(v - 0x41 + 10), // ord('A') == 0x41
-        b'a'..=b'f' => Some(v - 0x61 + 10), // ord('a') == 0x61
-        _ => None,
-    }
-}
-
 /// Decode a ASCII hex-encoded pair to an integer.
 ///
 /// Returns `None` if either portion of the decoded pair does not evaluate to a valid hex value.
@@ -160,64 +99,52 @@ fn from_ascii_hex(v: u8) -> Option<u8> {
 /// - `0x33 ('3'), 0x30 ('0') => 0x30 ('0')`
 /// - `0x34 ('4'), 0x31 ('1') => 0x41 ('A')`
 /// - `0x36 ('6'), 0x31 ('1') => 0x61 ('a')`
+#[inline(always)]
 fn hex_pair_to_char(d1: u8, d2: u8) -> Option<u8> {
-    let (d_high, d_low) = (from_ascii_hex(d1)?, from_ascii_hex(d2)?);
+    let d_high = char::from(d1).to_digit(16)?;
+    let d_low = char::from(d2).to_digit(16)?;
 
     // left shift high nibble by 4 bits
-    Some(d_high << 4 | d_low)
+    Some((d_high as u8) << 4 | (d_low as u8))
 }
 
-/// Sets bit in given bit-map to 1=true.
+#[derive(Debug, Default, Clone)]
-///
+struct AsciiBitmap {
-/// # Panics
+    array: [u8; 16],
-/// Panics if `ch` index is out of bounds.
-fn set_bit(array: &mut [u8], ch: u8) {
-    array[(ch >> 3) as usize] |= 0b1 << (ch & 0b111)
 }
 
-/// Returns true if bit to true in given bit-map.
+impl AsciiBitmap {
-///
+    /// Sets bit in given bit-map to 1=true.
-/// # Panics
+    ///
-/// Panics if `ch` index is out of bounds.
+    /// # Panics
-fn bit_at(array: &[u8], ch: u8) -> bool {
+    /// Panics if `ch` index is out of bounds.
-    array[(ch >> 3) as usize] & (0b1 << (ch & 0b111)) != 0
+    fn set_bit(&mut self, ch: u8) {
+        self.array[(ch >> 3) as usize] |= 0b1 << (ch & 0b111)
+    }
+
+    /// Returns true if bit to true in given bit-map.
+    ///
+    /// # Panics
+    /// Panics if `ch` index is out of bounds.
+    fn bit_at(&self, ch: u8) -> bool {
+        self.array[(ch >> 3) as usize] & (0b1 << (ch & 0b111)) != 0
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn hex_encoding() {
-        let hex = b"0123456789abcdefABCDEF";
-
-        for i in 0..256 {
-            let c = i as u8;
-            if hex.contains(&c) {
-                assert!(from_ascii_hex(c).is_some())
-            } else {
-                assert!(from_ascii_hex(c).is_none())
-            }
-        }
-
-        let expected = [
-            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15,
-        ];
-        for i in 0..hex.len() {
-            assert_eq!(from_ascii_hex(hex[i]).unwrap(), expected[i]);
-        }
-    }
-
     #[test]
     fn custom_quoter() {
         let q = Quoter::new(b"", b"+");
         assert_eq!(q.requote(b"/a%25c").unwrap(), b"/a%c");
-        assert_eq!(q.requote(b"/a%2Bc").unwrap(), b"/a%2Bc");
+        assert_eq!(q.requote(b"/a%2Bc"), None);
 
         let q = Quoter::new(b"%+", b"/");
         assert_eq!(q.requote(b"/a%25b%2Bc").unwrap(), b"/a%b+c");
-        assert_eq!(q.requote(b"/a%2fb").unwrap(), b"/a%2fb");
+        assert_eq!(q.requote(b"/a%2fb"), None);
-        assert_eq!(q.requote(b"/a%2Fb").unwrap(), b"/a%2Fb");
+        assert_eq!(q.requote(b"/a%2Fb"), None);
         assert_eq!(q.requote(b"/a%0Ab").unwrap(), b"/a\nb");
         assert_eq!(q.requote(b"/a%FE\xffb").unwrap(), b"/a\xfe\xffb");
         assert_eq!(q.requote(b"/a\xfe\xffb"), None);
@@ -233,7 +160,8 @@ mod tests {
     #[test]
     fn invalid_sequences() {
         let q = Quoter::new(b"%+", b"/");
-        assert_eq!(q.requote(b"/a%2x%2X%%").unwrap(), b"/a%2x%2X");
+        assert_eq!(q.requote(b"/a%2x%2X%%"), None);
+        assert_eq!(q.requote(b"/a%20%2X%%").unwrap(), b"/a %2X%%");
     }
 
     #[test]

actix-router/src/resource.rs

@@ -5,7 +5,6 @@ use std::{
     mem,
 };
 
-use firestorm::{profile_fn, profile_method, profile_section};
 use regex::{escape, Regex, RegexSet};
 use tracing::error;
 
@@ -272,7 +271,6 @@ impl ResourceDef {
     /// assert!(!resource.is_match("/foo"));
     /// ```
     pub fn new<T: IntoPatterns>(paths: T) -> Self {
-        profile_method!(new);
         Self::construct(paths, false)
     }
 
@@ -300,7 +298,6 @@ impl ResourceDef {
     /// assert!(!resource.is_match("/foo"));
     /// ```
     pub fn prefix<T: IntoPatterns>(paths: T) -> Self {
-        profile_method!(prefix);
         ResourceDef::construct(paths, true)
     }
 
@@ -325,7 +322,6 @@ impl ResourceDef {
     /// assert!(!resource.is_match("user/123"));
     /// ```
     pub fn root_prefix(path: &str) -> Self {
-        profile_method!(root_prefix);
         ResourceDef::prefix(insert_slash(path).into_owned())
     }
 
@@ -549,8 +545,6 @@ impl ResourceDef {
     /// ```
     #[inline]
     pub fn is_match(&self, path: &str) -> bool {
-        profile_method!(is_match);
-
         // this function could be expressed as:
         // `self.find_match(path).is_some()`
         // but this skips some checks and uses potentially faster regex methods
@@ -598,8 +592,6 @@ impl ResourceDef {
     /// assert_eq!(resource.find_match("/profile/1234"), Some(13));
     /// ```
     pub fn find_match(&self, path: &str) -> Option<usize> {
-        profile_method!(find_match);
-
         match &self.pat_type {
             PatternType::Static(pattern) => self.static_match(pattern, path),
 
@@ -634,7 +626,6 @@ impl ResourceDef {
     /// assert_eq!(path.unprocessed(), "");
     /// ```
     pub fn capture_match_info<R: Resource>(&self, resource: &mut R) -> bool {
-        profile_method!(capture_match_info);
         self.capture_match_info_fn(resource, |_| true)
     }
 
@@ -658,7 +649,7 @@ impl ResourceDef {
     ///     resource.capture_match_info_fn(
     ///         path,
     ///         // when env var is not set, reject when path contains "admin"
-    ///         |res| !(!admin_allowed && res.path().contains("admin")),
+    ///         |path| !(!admin_allowed && path.as_str().contains("admin")),
     ///     )
     /// }
     ///
@@ -680,37 +671,22 @@ impl ResourceDef {
         R: Resource,
         F: FnOnce(&R) -> bool,
     {
-        profile_method!(capture_match_info_fn);
-
         let mut segments = <[PathItem; MAX_DYNAMIC_SEGMENTS]>::default();
         let path = resource.resource_path();
         let path_str = path.unprocessed();
 
         let (matched_len, matched_vars) = match &self.pat_type {
-            PatternType::Static(pattern) => {
+            PatternType::Static(pattern) => match self.static_match(pattern, path_str) {
-                profile_section!(pattern_static_or_prefix);
-
-                match self.static_match(pattern, path_str) {
                 Some(len) => (len, None),
                 None => return false,
-                }
+            },
-            }
 
             PatternType::Dynamic(re, names) => {
-                profile_section!(pattern_dynamic);
+                let captures = match re.captures(path.unprocessed()) {
-
-                let captures = {
-                    profile_section!(pattern_dynamic_regex_exec);
-
-                    match re.captures(path.unprocessed()) {
                     Some(captures) => captures,
                     _ => return false,
-                    }
                 };
 
-                {
-                    profile_section!(pattern_dynamic_extract_captures);
-
                 for (no, name) in names.iter().enumerate() {
                     if let Some(m) = captures.name(name) {
                         segments[no] = PathItem::Segment(m.start() as u16, m.end() as u16);
@@ -719,14 +695,11 @@ impl ResourceDef {
                         return false;
                     }
                 }
-                };
 
                 (captures[1].len(), Some(names))
             }
 
             PatternType::DynamicSet(re, params) => {
-                profile_section!(pattern_dynamic_set);
-
                 let path = path.unprocessed();
                 let (pattern, names) = match re.matches(path).into_iter().next() {
                     Some(idx) => &params[idx],
@@ -809,7 +782,6 @@ impl ResourceDef {
         I: IntoIterator,
         I::Item: AsRef<str>,
     {
-        profile_method!(resource_path_from_iter);
         let mut iter = values.into_iter();
         self.build_resource_path(path, |_| iter.next())
     }
@@ -845,7 +817,6 @@ impl ResourceDef {
         V: AsRef<str>,
         S: BuildHasher,
     {
-        profile_method!(resource_path_from_map);
         self.build_resource_path(path, |name| values.get(name))
     }
 
@@ -866,8 +837,6 @@ impl ResourceDef {
     }
 
     fn construct<T: IntoPatterns>(paths: T, is_prefix: bool) -> Self {
-        profile_method!(construct);
-
         let patterns = paths.patterns();
         let (pat_type, segments) = match &patterns {
             Patterns::Single(pattern) => ResourceDef::parse(pattern, is_prefix, false),
@@ -926,8 +895,6 @@ impl ResourceDef {
     /// # Panics
     /// Panics if given patterns does not contain a dynamic segment.
     fn parse_param(pattern: &str) -> (PatternSegment, String, &str, bool) {
-        profile_method!(parse_param);
-
         const DEFAULT_PATTERN: &str = "[^/]+";
         const DEFAULT_PATTERN_TAIL: &str = ".*";
 
@@ -997,8 +964,6 @@ impl ResourceDef {
         is_prefix: bool,
         force_dynamic: bool,
     ) -> (PatternType, Vec<PatternSegment>) {
-        profile_method!(parse);
-
         if !force_dynamic && pattern.find('{').is_none() && !pattern.ends_with('*') {
             // pattern is static
             return (
@@ -1131,8 +1096,6 @@ impl From<String> for ResourceDef {
 }
 
 pub(crate) fn insert_slash(path: &str) -> Cow<'_, str> {
-    profile_fn!(insert_slash);
-
     if !path.is_empty() && !path.starts_with('/') {
         let mut new_path = String::with_capacity(path.len() + 1);
         new_path.push('/');
@@ -1540,31 +1503,31 @@ mod tests {
     fn build_path_list() {
         let mut s = String::new();
         let resource = ResourceDef::new("/user/{item1}/test");
-        assert!(resource.resource_path_from_iter(&mut s, &mut (&["user1"]).iter()));
+        assert!(resource.resource_path_from_iter(&mut s, &mut ["user1"].iter()));
         assert_eq!(s, "/user/user1/test");
 
         let mut s = String::new();
         let resource = ResourceDef::new("/user/{item1}/{item2}/test");
-        assert!(resource.resource_path_from_iter(&mut s, &mut (&["item", "item2"]).iter()));
+        assert!(resource.resource_path_from_iter(&mut s, &mut ["item", "item2"].iter()));
         assert_eq!(s, "/user/item/item2/test");
 
         let mut s = String::new();
         let resource = ResourceDef::new("/user/{item1}/{item2}");
-        assert!(resource.resource_path_from_iter(&mut s, &mut (&["item", "item2"]).iter()));
+        assert!(resource.resource_path_from_iter(&mut s, &mut ["item", "item2"].iter()));
         assert_eq!(s, "/user/item/item2");
 
         let mut s = String::new();
         let resource = ResourceDef::new("/user/{item1}/{item2}/");
-        assert!(resource.resource_path_from_iter(&mut s, &mut (&["item", "item2"]).iter()));
+        assert!(resource.resource_path_from_iter(&mut s, &mut ["item", "item2"].iter()));
         assert_eq!(s, "/user/item/item2/");
 
         let mut s = String::new();
-        assert!(!resource.resource_path_from_iter(&mut s, &mut (&["item"]).iter()));
+        assert!(!resource.resource_path_from_iter(&mut s, &mut ["item"].iter()));
 
         let mut s = String::new();
-        assert!(resource.resource_path_from_iter(&mut s, &mut (&["item", "item2"]).iter()));
+        assert!(resource.resource_path_from_iter(&mut s, &mut ["item", "item2"].iter()));
         assert_eq!(s, "/user/item/item2/");
-        assert!(!resource.resource_path_from_iter(&mut s, &mut (&["item"]).iter()));
+        assert!(!resource.resource_path_from_iter(&mut s, &mut ["item"].iter()));
 
         let mut s = String::new();
         assert!(resource.resource_path_from_iter(&mut s, &mut vec!["item", "item2"].iter()));
@@ -1641,10 +1604,10 @@ mod tests {
         let resource = ResourceDef::new("/user/{item1}*");
 
         let mut s = String::new();
-        assert!(!resource.resource_path_from_iter(&mut s, &mut (&[""; 0]).iter()));
+        assert!(!resource.resource_path_from_iter(&mut s, &mut [""; 0].iter()));
 
         let mut s = String::new();
-        assert!(resource.resource_path_from_iter(&mut s, &mut (&["user1"]).iter()));
+        assert!(resource.resource_path_from_iter(&mut s, &mut ["user1"].iter()));
         assert_eq!(s, "/user/user1");
 
         let mut s = String::new();

actix-router/src/resource_path.rs

@@ -27,7 +27,7 @@ impl<'a> ResourcePath for &'a str {
 
 impl ResourcePath for bytestring::ByteString {
     fn path(&self) -> &str {
-        &*self
+        self
     }
 }
 

actix-router/src/router.rs

@@ -1,8 +1,6 @@
-use firestorm::profile_method;
-
 use crate::{IntoPatterns, Resource, ResourceDef};
 
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct ResourceId(pub u16);
 
 /// Resource router.
@@ -30,7 +28,6 @@ impl<T, U> Router<T, U> {
     where
         R: Resource,
     {
-        profile_method!(recognize);
         self.recognize_fn(resource, |_, _| true)
     }
 
@@ -39,7 +36,6 @@ impl<T, U> Router<T, U> {
     where
         R: Resource,
     {
-        profile_method!(recognize_mut);
         self.recognize_mut_fn(resource, |_, _| true)
     }
 
@@ -55,8 +51,6 @@ impl<T, U> Router<T, U> {
         R: Resource,
         F: FnMut(&R, &U) -> bool,
     {
-        profile_method!(recognize_checked);
-
         for (rdef, val, ctx) in self.routes.iter() {
             if rdef.capture_match_info_fn(resource, |res| check(res, ctx)) {
                 return Some((val, ResourceId(rdef.id())));
@@ -77,8 +71,6 @@ impl<T, U> Router<T, U> {
         R: Resource,
         F: FnMut(&R, &U) -> bool,
     {
-        profile_method!(recognize_mut_checked);
-
         for (rdef, val, ctx) in self.routes.iter_mut() {
             if rdef.capture_match_info_fn(resource, |res| check(res, ctx)) {
                 return Some((val, ResourceId(rdef.id())));
@@ -104,7 +96,6 @@ impl<T, U> RouterBuilder<T, U> {
         val: T,
         ctx: U,
     ) -> (&mut ResourceDef, &mut T, &mut U) {
-        profile_method!(push);
         self.routes.push((rdef, val, ctx));
         self.routes
             .last_mut()
@@ -131,7 +122,6 @@ where
         path: impl IntoPatterns,
         val: T,
     ) -> (&mut ResourceDef, &mut T, &mut U) {
-        profile_method!(path);
         self.push(ResourceDef::new(path), val, U::default())
     }
 
@@ -141,13 +131,11 @@ where
         prefix: impl IntoPatterns,
         val: T,
     ) -> (&mut ResourceDef, &mut T, &mut U) {
-        profile_method!(prefix);
         self.push(ResourceDef::prefix(prefix), val, U::default())
     }
 
     /// Registers resource for [`ResourceDef`].
     pub fn rdef(&mut self, rdef: ResourceDef, val: T) -> (&mut ResourceDef, &mut T, &mut U) {
-        profile_method!(rdef);
         self.push(rdef, val, U::default())
     }
 }

actix-router/src/url.rs

@@ -3,7 +3,7 @@ use crate::ResourcePath;
 use crate::Quoter;
 
 thread_local! {
-    static DEFAULT_QUOTER: Quoter = Quoter::new(b"@:", b"%/+");
+    static DEFAULT_QUOTER: Quoter = Quoter::new(b"", b"%/+");
 }
 
 #[derive(Debug, Clone, Default)]

actix-test/CHANGES.md

@@ -1,6 +1,11 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.
+
+
+## 0.1.0 - 2022-07-24
+- Minimum supported Rust version (MSRV) is now 1.57 due to transitive `time` dependency.
 
 
 ## 0.1.0-beta.13 - 2022-02-16

actix-test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-test"
-version = "0.1.0-beta.13"
+version = "0.1.0"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Rob Ede <robjtede@icloud.com>",
@@ -30,7 +30,7 @@ openssl = ["tls-openssl", "actix-http/openssl", "awc/openssl"]
 [dependencies]
 actix-codec = "0.5"
 actix-http = "3"
-actix-http-test = "3.0.0-beta.13"
+actix-http-test = "3"
 actix-rt = "2.1"
 actix-service = "2"
 actix-utils = "3"

actix-web-actors/CHANGES.md

@@ -1,6 +1,7 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+- Minimum supported Rust version (MSRV) is now 1.57 due to transitive `time` dependency.
 
 
 ## 4.1.0 - 2022-03-02

actix-web-actors/Cargo.toml

@@ -27,8 +27,11 @@ tokio = { version = "1.13.1", features = ["sync"] }
 
 [dev-dependencies]
 actix-rt = "2.2"
-actix-test = "0.1.0-beta.13"
+actix-test = "0.1"
 awc = { version = "3", default-features = false }
+actix-web = { version = "4", features = ["macros"] }
+
+mime = "0.3"
 
 env_logger = "0.9"
 futures-util = { version = "0.3.7", default-features = false }

actix-web-actors/README.md

@@ -4,7 +4,7 @@
 
 [![crates.io](https://img.shields.io/crates/v/actix-web-actors?label=latest)](https://crates.io/crates/actix-web-actors)
 [![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.1.0)](https://docs.rs/actix-web-actors/4.1.0)
-[![Version](https://img.shields.io/badge/rustc-1.54+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.54.0.html)
+![Version](https://img.shields.io/badge/rustc-1.59+-ab6000.svg)
 ![License](https://img.shields.io/crates/l/actix-web-actors.svg)
 <br />
 [![dependency status](https://deps.rs/crate/actix-web-actors/4.1.0/status.svg)](https://deps.rs/crate/actix-web-actors/4.1.0)

actix-web-actors/src/context.rs

@@ -14,6 +14,58 @@ use futures_core::Stream;
 use tokio::sync::oneshot::Sender;
 
 /// Execution context for HTTP actors
+///
+/// # Example
+///
+/// A demonstration of [server-sent events](https://developer.mozilla.org/docs/Web/API/Server-sent_events) using actors:
+///
+/// ```no_run
+/// use std::time::Duration;
+///
+/// use actix::{Actor, AsyncContext};
+/// use actix_web::{get, http::header, App, HttpResponse, HttpServer};
+/// use actix_web_actors::HttpContext;
+/// use bytes::Bytes;
+///
+/// struct MyActor {
+///     count: usize,
+/// }
+///
+/// impl Actor for MyActor {
+///     type Context = HttpContext<Self>;
+///
+///     fn started(&mut self, ctx: &mut Self::Context) {
+///         ctx.run_later(Duration::from_millis(100), Self::write);
+///     }
+/// }
+///
+/// impl MyActor {
+///     fn write(&mut self, ctx: &mut HttpContext<Self>) {
+///         self.count += 1;
+///         if self.count > 3 {
+///             ctx.write_eof()
+///         } else {
+///             ctx.write(Bytes::from(format!("event: count\ndata: {}\n\n", self.count)));
+///             ctx.run_later(Duration::from_millis(100), Self::write);
+///         }
+///     }
+/// }
+///
+/// #[get("/")]
+/// async fn index() -> HttpResponse {
+///     HttpResponse::Ok()
+///         .insert_header(header::ContentType(mime::TEXT_EVENT_STREAM))
+///         .streaming(HttpContext::create(MyActor { count: 0 }))
+/// }
+///
+/// #[actix_web::main]
+/// async fn main() -> std::io::Result<()> {
+///     HttpServer::new(|| App::new().service(index))
+///         .bind(("127.0.0.1", 8080))?
+///         .run()
+///         .await
+/// }
+/// ```
 pub struct HttpContext<A>
 where
     A: Actor<Context = HttpContext<A>>,
@@ -210,7 +262,7 @@ mod tests {
         type Context = HttpContext<Self>;
 
         fn started(&mut self, ctx: &mut Self::Context) {
-            ctx.run_later(Duration::from_millis(100), |slf, ctx| slf.write(ctx));
+            ctx.run_later(Duration::from_millis(100), Self::write);
         }
     }
 
@@ -221,7 +273,7 @@ mod tests {
                 ctx.write_eof()
             } else {
                 ctx.write(Bytes::from(format!("LINE-{}", self.count)));
-                ctx.run_later(Duration::from_millis(100), |slf, ctx| slf.write(ctx));
+                ctx.run_later(Duration::from_millis(100), Self::write);
             }
         }
     }

actix-web-actors/src/lib.rs

@@ -1,4 +1,59 @@
 //! Actix actors support for Actix Web.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! use actix::{Actor, StreamHandler};
+//! use actix_web::{get, web, App, Error, HttpRequest, HttpResponse, HttpServer};
+//! use actix_web_actors::ws;
+//!
+//! /// Define Websocket actor
+//! struct MyWs;
+//!
+//! impl Actor for MyWs {
+//!     type Context = ws::WebsocketContext<Self>;
+//! }
+//!
+//! /// Handler for ws::Message message
+//! impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWs {
+//!     fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
+//!         match msg {
+//!             Ok(ws::Message::Ping(msg)) => ctx.pong(&msg),
+//!             Ok(ws::Message::Text(text)) => ctx.text(text),
+//!             Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
+//!             _ => (),
+//!         }
+//!     }
+//! }
+//!
+//! #[get("/ws")]
+//! async fn index(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
+//!     ws::start(MyWs, &req, stream)
+//! }
+//!
+//! #[actix_web::main]
+//! async fn main() -> std::io::Result<()> {
+//!     HttpServer::new(|| App::new().service(index))
+//!         .bind(("127.0.0.1", 8080))?
+//!         .run()
+//!         .await
+//! }
+//! ```
+//!
+//! # Documentation & Community Resources
+//! In addition to this API documentation, several other resources are available:
+//!
+//! * [Website & User Guide](https://actix.rs/)
+//! * [Documentation for `actix_web`](actix_web)
+//! * [Examples Repository](https://github.com/actix/examples)
+//! * [Community Chat on Discord](https://discord.gg/NWpN5mmg3x)
+//!
+//! To get started navigating the API docs, you may consider looking at the following pages first:
+//!
+//! * [`ws`]: This module provides actor support for WebSockets.
+//!
+//! * [`HttpContext`]: This struct provides actor support for streaming HTTP responses.
+//!
 
 #![deny(rust_2018_idioms, nonstandard_style)]
 #![warn(future_incompatible)]

actix-web-actors/src/ws.rs

@@ -1,4 +1,60 @@
 //! Websocket integration.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! use actix::{Actor, StreamHandler};
+//! use actix_web::{get, web, App, Error, HttpRequest, HttpResponse, HttpServer};
+//! use actix_web_actors::ws;
+//!
+//! /// Define Websocket actor
+//! struct MyWs;
+//!
+//! impl Actor for MyWs {
+//!     type Context = ws::WebsocketContext<Self>;
+//! }
+//!
+//! /// Handler for ws::Message message
+//! impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWs {
+//!     fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
+//!         match msg {
+//!             Ok(ws::Message::Ping(msg)) => ctx.pong(&msg),
+//!             Ok(ws::Message::Text(text)) => ctx.text(text),
+//!             Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
+//!             _ => (),
+//!         }
+//!     }
+//! }
+//!
+//! #[get("/ws")]
+//! async fn websocket(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
+//!     ws::start(MyWs, &req, stream)
+//! }
+//!
+//! const MAX_FRAME_SIZE: usize = 16_384; // 16KiB
+//!
+//! #[get("/custom-ws")]
+//! async fn custom_websocket(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
+//!     // Create a Websocket session with a specific max frame size, and protocols.
+//!     ws::WsResponseBuilder::new(MyWs, &req, stream)
+//!         .frame_size(MAX_FRAME_SIZE)
+//!         .protocols(&["A", "B"])
+//!         .start()
+//! }
+//!
+//! #[actix_web::main]
+//! async fn main() -> std::io::Result<()> {
+//!     HttpServer::new(|| {
+//!             App::new()
+//!                 .service(websocket)
+//!                 .service(custom_websocket)
+//!         })
+//!         .bind(("127.0.0.1", 8080))?
+//!         .run()
+//!         .await
+//! }
+//! ```
+//!
 
 use std::{
     collections::VecDeque,
@@ -41,20 +97,51 @@ use tokio::sync::oneshot;
 ///
 /// # Examples
 ///
-/// Create a Websocket session response with default configuration.
+/// ```no_run
-/// ```ignore
+/// # use actix::{Actor, StreamHandler};
-/// WsResponseBuilder::new(WsActor, &req, stream).start()
+/// # use actix_web::{get, web, App, Error, HttpRequest, HttpResponse, HttpServer};
-/// ```
+/// # use actix_web_actors::ws;
+/// #
+/// # struct MyWs;
+/// #
+/// # impl Actor for MyWs {
+/// #     type Context = ws::WebsocketContext<Self>;
+/// # }
+/// #
+/// # /// Handler for ws::Message message
+/// # impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWs {
+/// #     fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {}
+/// # }
+/// #
+/// #[get("/ws")]
+/// async fn websocket(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
+///     ws::WsResponseBuilder::new(MyWs, &req, stream).start()
+/// }
 ///
-/// Create a Websocket session with a specific max frame size, [`Codec`], and protocols.
-/// ```ignore
 /// const MAX_FRAME_SIZE: usize = 16_384; // 16KiB
 ///
-/// ws::WsResponseBuilder::new(WsActor, &req, stream)
+/// #[get("/custom-ws")]
-///     .codec(Codec::new())
+/// async fn custom_websocket(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
-///     .protocols(&["A", "B"])
+///     // Create a Websocket session with a specific max frame size, codec, and protocols.
+///     ws::WsResponseBuilder::new(MyWs, &req, stream)
+///         .codec(actix_http::ws::Codec::new())
+///         // This will overwrite the codec's max frame-size
 ///         .frame_size(MAX_FRAME_SIZE)
+///         .protocols(&["A", "B"])
 ///         .start()
+/// }
+/// #
+/// # #[actix_web::main]
+/// # async fn main() -> std::io::Result<()> {
+/// #     HttpServer::new(|| {
+/// #             App::new()
+/// #                 .service(websocket)
+/// #                 .service(custom_websocket)
+/// #         })
+/// #         .bind(("127.0.0.1", 8080))?
+/// #         .run()
+/// #         .await
+/// # }
 /// ```
 pub struct WsResponseBuilder<'a, A, T>
 where

actix-web-codegen/CHANGES.md

@@ -1,6 +1,20 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+
+
+## 4.1.0 - 2022-09-11
+- Add `#[routes]` macro to support multiple paths for one handler. [#2718]
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.
+
+[#2718]: https://github.com/actix/actix-web/pull/2718
+
+
+## 4.0.1 - 2022-06-11
+- Fix support for guard paths in route handler macros. [#2771]
+- Minimum supported Rust version (MSRV) is now 1.56 due to transitive `hashbrown` dependency.
+
+[#2771]: https://github.com/actix/actix-web/pull/2771
 
 
 ## 4.0.0 - 2022-02-24

actix-web-codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web-codegen"
-version = "4.0.0"
+version = "4.1.0"
 description = "Routing and runtime macros for Actix Web"
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
@@ -15,17 +15,17 @@ edition = "2018"
 proc-macro = true
 
 [dependencies]
-actix-router = "0.5.0"
+actix-router = "0.5"
 proc-macro2 = "1"
 quote = "1"
-syn = { version = "1", features = ["full", "parsing"] }
+syn = { version = "1", features = ["full", "extra-traits"] }
 
 [dev-dependencies]
 actix-macros = "0.2.3"
 actix-rt = "2.2"
-actix-test = "0.1.0-beta.13"
+actix-test = "0.1"
-actix-utils = "3.0.0"
+actix-utils = "3"
-actix-web = "4.0.0"
+actix-web = "4"
 
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
 trybuild = "1"

actix-web-codegen/README.md

@@ -3,11 +3,11 @@
 > Routing and runtime macros for Actix Web.
 
 [![crates.io](https://img.shields.io/crates/v/actix-web-codegen?label=latest)](https://crates.io/crates/actix-web-codegen)
-[![Documentation](https://docs.rs/actix-web-codegen/badge.svg?version=4.0.0)](https://docs.rs/actix-web-codegen/4.0.0)
+[![Documentation](https://docs.rs/actix-web-codegen/badge.svg?version=4.1.0)](https://docs.rs/actix-web-codegen/4.1.0)
-[![Version](https://img.shields.io/badge/rustc-1.54+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.54.0.html)
+![Version](https://img.shields.io/badge/rustc-1.59+-ab6000.svg)
 ![License](https://img.shields.io/crates/l/actix-web-codegen.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-web-codegen/4.0.0/status.svg)](https://deps.rs/crate/actix-web-codegen/4.0.0)
+[![dependency status](https://deps.rs/crate/actix-web-codegen/4.1.0/status.svg)](https://deps.rs/crate/actix-web-codegen/4.1.0)
 [![Download](https://img.shields.io/crates/d/actix-web-codegen.svg)](https://crates.io/crates/actix-web-codegen)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 

actix-web-codegen/src/lib.rs

@@ -46,9 +46,20 @@
 //! ```
 //!
 //! # Multiple Path Handlers
-//! There are no macros to generate multi-path handlers. Let us know in [this issue].
+//! Acts as a wrapper for multiple single method handler macros. It takes no arguments and
+//! delegates those to the macros for the individual methods. See [macro@routes] macro docs.
 //!
-//! [this issue]: https://github.com/actix/actix-web/issues/1709
+//! ```
+//! # use actix_web::HttpResponse;
+//! # use actix_web_codegen::routes;
+//! #[routes]
+//! #[get("/test")]
+//! #[get("/test2")]
+//! #[delete("/test")]
+//! async fn example() -> HttpResponse {
+//!     HttpResponse::Ok().finish()
+//! }
+//! ```
 //!
 //! [actix-web attributes docs]: https://docs.rs/actix-web/latest/actix_web/#attributes
 //! [GET]: macro@get
@@ -104,6 +115,39 @@ pub fn route(args: TokenStream, input: TokenStream) -> TokenStream {
     route::with_method(None, args, input)
 }
 
+/// Creates resource handler, allowing multiple HTTP methods and paths.
+///
+/// # Syntax
+/// ```plain
+/// #[routes]
+/// #[<method>("path", ...)]
+/// #[<method>("path", ...)]
+/// ...
+/// ```
+///
+/// # Attributes
+/// The `routes` macro itself has no parameters, but allows specifying the attribute macros for
+/// the multiple paths and/or methods, e.g. [`GET`](macro@get) and [`POST`](macro@post).
+///
+/// These helper attributes take the same parameters as the [single method handlers](crate#single-method-handler).
+///
+/// # Examples
+/// ```
+/// # use actix_web::HttpResponse;
+/// # use actix_web_codegen::routes;
+/// #[routes]
+/// #[get("/test")]
+/// #[get("/test2")]
+/// #[delete("/test")]
+/// async fn example() -> HttpResponse {
+///     HttpResponse::Ok().finish()
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn routes(_: TokenStream, input: TokenStream) -> TokenStream {
+    route::with_methods(input)
+}
+
 macro_rules! method_macro {
     ($variant:ident, $method:ident) => {
 #[doc = concat!("Creates route handler with `actix_web::guard::", stringify!($variant), "`.")]

actix-web-codegen/src/route.rs

@@ -3,24 +3,12 @@ use std::{collections::HashSet, convert::TryFrom};
 use actix_router::ResourceDef;
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
-use quote::{format_ident, quote, ToTokens, TokenStreamExt};
+use quote::{quote, ToTokens, TokenStreamExt};
-use syn::{parse_macro_input, AttributeArgs, Ident, LitStr, NestedMeta};
+use syn::{parse_macro_input, AttributeArgs, Ident, LitStr, Meta, NestedMeta, Path};
-
-enum ResourceType {
-    Async,
-    Sync,
-}
-
-impl ToTokens for ResourceType {
-    fn to_tokens(&self, stream: &mut TokenStream2) {
-        let ident = format_ident!("to");
-        stream.append(ident);
-    }
-}
 
 macro_rules! method_type {
     (
-        $($variant:ident, $upper:ident,)+
+        $($variant:ident, $upper:ident, $lower:ident,)+
     ) => {
         #[derive(Debug, PartialEq, Eq, Hash)]
         pub enum MethodType {
@@ -42,20 +30,27 @@ macro_rules! method_type {
                     _ => Err(format!("Unexpected HTTP method: `{}`", method)),
                 }
             }
+
+            fn from_path(method: &Path) -> Result<Self, ()> {
+                match () {
+                    $(_ if method.is_ident(stringify!($lower)) => Ok(Self::$variant),)+
+                    _ => Err(()),
+                }
+            }
         }
     };
 }
 
 method_type! {
-    Get,       GET,
+    Get,       GET,     get,
-    Post,      POST,
+    Post,      POST,    post,
-    Put,       PUT,
+    Put,       PUT,     put,
-    Delete,    DELETE,
+    Delete,    DELETE,  delete,
-    Head,      HEAD,
+    Head,      HEAD,    head,
-    Connect,   CONNECT,
+    Connect,   CONNECT, connect,
-    Options,   OPTIONS,
+    Options,   OPTIONS, options,
-    Trace,     TRACE,
+    Trace,     TRACE,   trace,
-    Patch,     PATCH,
+    Patch,     PATCH,   patch,
 }
 
 impl ToTokens for MethodType {
@@ -77,7 +72,7 @@ impl TryFrom<&syn::LitStr> for MethodType {
 struct Args {
     path: syn::LitStr,
     resource_name: Option<syn::LitStr>,
-    guards: Vec<Ident>,
+    guards: Vec<Path>,
     wrappers: Vec<syn::Type>,
     methods: HashSet<MethodType>,
 }
@@ -90,6 +85,18 @@ impl Args {
         let mut wrappers = Vec::new();
         let mut methods = HashSet::new();
 
+        if args.is_empty() {
+            return Err(syn::Error::new(
+                Span::call_site(),
+                format!(
+                    r#"invalid service definition, expected #[{}("<path>")]"#,
+                    method
+                        .map_or("route", |it| it.as_str())
+                        .to_ascii_lowercase()
+                ),
+            ));
+        }
+
         let is_route_macro = method.is_none();
         if let Some(method) = method {
             methods.insert(method);
@@ -121,7 +128,7 @@ impl Args {
                         }
                     } else if nv.path.is_ident("guard") {
                         if let syn::Lit::Str(lit) = nv.lit {
-                            guards.push(Ident::new(&lit.value(), Span::call_site()));
+                            guards.push(lit.parse::<Path>()?);
                         } else {
                             return Err(syn::Error::new_spanned(
                                 nv.lit,
@@ -183,55 +190,27 @@ impl Args {
 }
 
 pub struct Route {
+    /// Name of the handler function being annotated.
     name: syn::Ident,
-    args: Args,
+
+    /// Args passed to routing macro.
+    ///
+    /// When using `#[routes]`, this will contain args for each specific routing macro.
+    args: Vec<Args>,
+
+    /// AST of the handler function being annotated.
     ast: syn::ItemFn,
-    resource_type: ResourceType,
 
     /// The doc comment attributes to copy to generated struct, if any.
     doc_attributes: Vec<syn::Attribute>,
 }
 
-fn guess_resource_type(typ: &syn::Type) -> ResourceType {
-    let mut guess = ResourceType::Sync;
-
-    if let syn::Type::ImplTrait(typ) = typ {
-        for bound in typ.bounds.iter() {
-            if let syn::TypeParamBound::Trait(bound) = bound {
-                for bound in bound.path.segments.iter() {
-                    if bound.ident == "Future" {
-                        guess = ResourceType::Async;
-                        break;
-                    } else if bound.ident == "Responder" {
-                        guess = ResourceType::Sync;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    guess
-}
-
 impl Route {
     pub fn new(
         args: AttributeArgs,
         ast: syn::ItemFn,
         method: Option<MethodType>,
     ) -> syn::Result<Self> {
-        if args.is_empty() {
-            return Err(syn::Error::new(
-                Span::call_site(),
-                format!(
-                    r#"invalid service definition, expected #[{}("<some path>")]"#,
-                    method
-                        .map_or("route", |it| it.as_str())
-                        .to_ascii_lowercase()
-                ),
-            ));
-        }
-
         let name = ast.sig.ident.clone();
 
         // Try and pull out the doc comments so that we can reapply them to the generated struct.
@@ -244,6 +223,7 @@ impl Route {
             .collect();
 
         let args = Args::new(args, method)?;
+
         if args.methods.is_empty() {
             return Err(syn::Error::new(
                 Span::call_site(),
@@ -251,25 +231,44 @@ impl Route {
             ));
         }
 
-        let resource_type = if ast.sig.asyncness.is_some() {
+        if matches!(ast.sig.output, syn::ReturnType::Default) {
-            ResourceType::Async
-        } else {
-            match ast.sig.output {
-                syn::ReturnType::Default => {
             return Err(syn::Error::new_spanned(
                 ast,
                 "Function has no return type. Cannot be used as handler",
             ));
         }
-                syn::ReturnType::Type(_, ref typ) => guess_resource_type(typ.as_ref()),
+
+        Ok(Self {
+            name,
+            args: vec![args],
+            ast,
+            doc_attributes,
+        })
+    }
+
+    fn multiple(args: Vec<Args>, ast: syn::ItemFn) -> syn::Result<Self> {
+        let name = ast.sig.ident.clone();
+
+        // Try and pull out the doc comments so that we can reapply them to the generated struct.
+        // Note that multi line doc comments are converted to multiple doc attributes.
+        let doc_attributes = ast
+            .attrs
+            .iter()
+            .filter(|attr| attr.path.is_ident("doc"))
+            .cloned()
+            .collect();
+
+        if matches!(ast.sig.output, syn::ReturnType::Default) {
+            return Err(syn::Error::new_spanned(
+                ast,
+                "Function has no return type. Cannot be used as handler",
+            ));
         }
-        };
 
         Ok(Self {
             name,
             args,
             ast,
-            resource_type,
             doc_attributes,
         })
     }
@@ -280,22 +279,28 @@ impl ToTokens for Route {
         let Self {
             name,
             ast,
-            args:
+            args,
-                Args {
+            doc_attributes,
+        } = self;
+
+        let registrations: TokenStream2 = args
+            .iter()
+            .map(|args| {
+                let Args {
                     path,
                     resource_name,
                     guards,
                     wrappers,
                     methods,
-                },
+                } = args;
-            resource_type,
+
-            doc_attributes,
-        } = self;
                 let resource_name = resource_name
                     .as_ref()
                     .map_or_else(|| name.to_string(), LitStr::value);
+
                 let method_guards = {
                     let mut others = methods.iter();
+
                     // unwrapping since length is checked to be at least one
                     let first = others.next().unwrap();
 
@@ -313,6 +318,19 @@ impl ToTokens for Route {
                     }
                 };
 
+                quote! {
+                    let __resource = ::actix_web::Resource::new(#path)
+                        .name(#resource_name)
+                        #method_guards
+                        #(.guard(::actix_web::guard::fn_guard(#guards)))*
+                        #(.wrap(#wrappers))*
+                        .to(#name);
+
+                    ::actix_web::dev::HttpServiceFactory::register(__resource, __config);
+                }
+            })
+            .collect();
+
         let stream = quote! {
             #(#doc_attributes)*
             #[allow(non_camel_case_types, missing_docs)]
@@ -321,14 +339,7 @@ impl ToTokens for Route {
             impl ::actix_web::dev::HttpServiceFactory for #name {
                 fn register(self, __config: &mut actix_web::dev::AppService) {
                     #ast
-                    let __resource = ::actix_web::Resource::new(#path)
+                    #registrations
-                        .name(#resource_name)
-                        #method_guards
-                        #(.guard(::actix_web::guard::fn_guard(#guards)))*
-                        #(.wrap(#wrappers))*
-                        .#resource_type(#name);
-
-                    ::actix_web::dev::HttpServiceFactory::register(__resource, __config)
                 }
             }
         };
@@ -357,6 +368,57 @@ pub(crate) fn with_method(
     }
 }
 
+pub(crate) fn with_methods(input: TokenStream) -> TokenStream {
+    let mut ast = match syn::parse::<syn::ItemFn>(input.clone()) {
+        Ok(ast) => ast,
+        // on parse error, make IDEs happy; see fn docs
+        Err(err) => return input_and_compile_error(input, err),
+    };
+
+    let (methods, others) = ast
+        .attrs
+        .into_iter()
+        .map(|attr| match MethodType::from_path(&attr.path) {
+            Ok(method) => Ok((method, attr)),
+            Err(_) => Err(attr),
+        })
+        .partition::<Vec<_>, _>(Result::is_ok);
+
+    ast.attrs = others.into_iter().map(Result::unwrap_err).collect();
+
+    let methods =
+        match methods
+            .into_iter()
+            .map(Result::unwrap)
+            .map(|(method, attr)| {
+                attr.parse_meta().and_then(|args| {
+                    if let Meta::List(args) = args {
+                        Args::new(args.nested.into_iter().collect(), Some(method))
+                    } else {
+                        Err(syn::Error::new_spanned(attr, "Invalid input for macro"))
+                    }
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()
+        {
+            Ok(methods) if methods.is_empty() => return input_and_compile_error(
+                input,
+                syn::Error::new(
+                    Span::call_site(),
+                    "The #[routes] macro requires at least one `#[<method>(..)]` attribute.",
+                ),
+            ),
+            Ok(methods) => methods,
+            Err(err) => return input_and_compile_error(input, err),
+        };
+
+    match Route::multiple(methods, ast) {
+        Ok(route) => route.into_token_stream().into(),
+        // on macro related error, make IDEs happy; see fn docs
+        Err(err) => input_and_compile_error(input, err),
+    }
+}
+
 /// Converts the error to a token stream and appends it to the original input.
 ///
 /// Returning the original input in addition to the error is good for IDEs which can gracefully

actix-web-codegen/tests/test_macro.rs

@@ -8,9 +8,11 @@ use actix_web::{
         header::{HeaderName, HeaderValue},
         StatusCode,
     },
-    web, App, Error, HttpResponse, Responder,
+    web, App, Error, HttpRequest, HttpResponse, Responder,
+};
+use actix_web_codegen::{
+    connect, delete, get, head, options, patch, post, put, route, routes, trace,
 };
-use actix_web_codegen::{connect, delete, get, head, options, patch, post, put, route, trace};
 use futures_core::future::LocalBoxFuture;
 
 // Make sure that we can name function as 'config'
@@ -89,13 +91,61 @@ async fn route_test() -> impl Responder {
     HttpResponse::Ok()
 }
 
+#[routes]
+#[get("/routes/test")]
+#[get("/routes/test2")]
+#[post("/routes/test")]
+async fn routes_test() -> impl Responder {
+    HttpResponse::Ok()
+}
+
+// routes overlap with the more specific route first, therefore accessible
+#[routes]
+#[get("/routes/overlap/test")]
+#[get("/routes/overlap/{foo}")]
+async fn routes_overlapping_test(req: HttpRequest) -> impl Responder {
+    // foo is only populated when route is not /routes/overlap/test
+    match req.match_info().get("foo") {
+        None => assert!(req.uri() == "/routes/overlap/test"),
+        Some(_) => assert!(req.uri() != "/routes/overlap/test"),
+    }
+
+    HttpResponse::Ok()
+}
+
+// routes overlap with the more specific route last, therefore inaccessible
+#[routes]
+#[get("/routes/overlap2/{foo}")]
+#[get("/routes/overlap2/test")]
+async fn routes_overlapping_inaccessible_test(req: HttpRequest) -> impl Responder {
+    // foo is always populated even when path is /routes/overlap2/test
+    assert!(req.match_info().get("foo").is_some());
+
+    HttpResponse::Ok()
+}
+
 #[get("/custom_resource_name", name = "custom")]
-async fn custom_resource_name_test<'a>(req: actix_web::HttpRequest) -> impl Responder {
+async fn custom_resource_name_test<'a>(req: HttpRequest) -> impl Responder {
     assert!(req.url_for_static("custom").is_ok());
     assert!(req.url_for_static("custom_resource_name_test").is_err());
     HttpResponse::Ok()
 }
 
+mod guard_module {
+    use actix_web::{guard::GuardContext, http::header};
+
+    pub fn guard(ctx: &GuardContext) -> bool {
+        ctx.header::<header::Accept>()
+            .map(|h| h.preference() == "image/*")
+            .unwrap_or(false)
+    }
+}
+
+#[get("/test/guard", guard = "guard_module::guard")]
+async fn guard_test() -> impl Responder {
+    HttpResponse::Ok()
+}
+
 pub struct ChangeStatusCode;
 
 impl<S, B> Transform<S, ServiceRequest> for ChangeStatusCode
@@ -186,7 +236,11 @@ async fn test_body() {
             .service(patch_test)
             .service(test_handler)
             .service(route_test)
+            .service(routes_overlapping_test)
+            .service(routes_overlapping_inaccessible_test)
+            .service(routes_test)
             .service(custom_resource_name_test)
+            .service(guard_test)
     });
     let request = srv.request(http::Method::GET, srv.url("/test"));
     let response = request.send().await.unwrap();
@@ -242,9 +296,47 @@ async fn test_body() {
     let response = request.send().await.unwrap();
     assert!(!response.status().is_success());
 
+    let request = srv.request(http::Method::GET, srv.url("/routes/test"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::GET, srv.url("/routes/test2"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::POST, srv.url("/routes/test"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::GET, srv.url("/routes/not-set"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_client_error());
+
+    let request = srv.request(http::Method::GET, srv.url("/routes/overlap/test"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::GET, srv.url("/routes/overlap/bar"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::GET, srv.url("/routes/overlap2/test"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::GET, srv.url("/routes/overlap2/bar"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
     let request = srv.request(http::Method::GET, srv.url("/custom_resource_name"));
     let response = request.send().await.unwrap();
     assert!(response.status().is_success());
+
+    let request = srv
+        .request(http::Method::GET, srv.url("/test/guard"))
+        .insert_header(("Accept", "image/*"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
 }
 
 #[actix_rt::test]

actix-web-codegen/tests/trybuild.rs

@@ -1,4 +1,4 @@
-#[rustversion::stable(1.54)] // MSRV
+#[rustversion::stable(1.59)] // MSRV
 #[test]
 fn compile_macros() {
     let t = trybuild::TestCases::new();
@@ -12,6 +12,10 @@ fn compile_macros() {
     t.compile_fail("tests/trybuild/route-unexpected-method-fail.rs");
     t.compile_fail("tests/trybuild/route-malformed-path-fail.rs");
 
+    t.pass("tests/trybuild/routes-ok.rs");
+    t.compile_fail("tests/trybuild/routes-missing-method-fail.rs");
+    t.compile_fail("tests/trybuild/routes-missing-args-fail.rs");
+
     t.pass("tests/trybuild/docstring-ok.rs");
 
     t.pass("tests/trybuild/test-runtime.rs");

actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr

@@ -1,11 +1,19 @@
 error: HTTP method defined more than once: `GET`
- --> $DIR/route-duplicate-method-fail.rs:3:35
+ --> tests/trybuild/route-duplicate-method-fail.rs:3:35
   |
 3 | #[route("/", method="GET", method="GET")]
   |                                   ^^^^^
 
-error[E0277]: the trait bound `fn() -> impl std::future::Future {index}: HttpServiceFactory` is not satisfied
+error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String> {index}: HttpServiceFactory` is not satisfied
-  --> $DIR/route-duplicate-method-fail.rs:12:55
+   --> tests/trybuild/route-duplicate-method-fail.rs:12:55
     |
 12  |     let srv = actix_test::start(|| App::new().service(index));
-   |                                                       ^^^^^ the trait `HttpServiceFactory` is not implemented for `fn() -> impl std::future::Future {index}`
+    |                                               ------- ^^^^^ the trait `HttpServiceFactory` is not implemented for `fn() -> impl std::future::Future<Output = String> {index}`
+    |                                               |
+    |                                               required by a bound introduced by this call
+    |
+note: required by a bound in `App::<T>::service`
+   --> $WORKSPACE/actix-web/src/app.rs
+    |
+    |         F: HttpServiceFactory + 'static,
+    |            ^^^^^^^^^^^^^^^^^^ required by this bound in `App::<T>::service`

actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr

@@ -6,8 +6,16 @@ error: The #[route(..)] macro requires at least one `method` attribute
   |
   = note: this error originates in the attribute macro `route` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0277]: the trait bound `fn() -> impl std::future::Future {index}: HttpServiceFactory` is not satisfied
+error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String> {index}: HttpServiceFactory` is not satisfied
    --> tests/trybuild/route-missing-method-fail.rs:12:55
     |
 12  |     let srv = actix_test::start(|| App::new().service(index));
-   |                                                       ^^^^^ the trait `HttpServiceFactory` is not implemented for `fn() -> impl std::future::Future {index}`
+    |                                               ------- ^^^^^ the trait `HttpServiceFactory` is not implemented for `fn() -> impl std::future::Future<Output = String> {index}`
+    |                                               |
+    |                                               required by a bound introduced by this call
+    |
+note: required by a bound in `App::<T>::service`
+   --> $WORKSPACE/actix-web/src/app.rs
+    |
+    |         F: HttpServiceFactory + 'static,
+    |            ^^^^^^^^^^^^^^^^^^ required by this bound in `App::<T>::service`

actix-web-codegen/tests/trybuild/route-unexpected-method-fail.stderr

@@ -1,11 +1,19 @@
 error: Unexpected HTTP method: `UNEXPECTED`
- --> $DIR/route-unexpected-method-fail.rs:3:21
+ --> tests/trybuild/route-unexpected-method-fail.rs:3:21
   |
 3 | #[route("/", method="UNEXPECTED")]
   |                     ^^^^^^^^^^^^
 
-error[E0277]: the trait bound `fn() -> impl std::future::Future {index}: HttpServiceFactory` is not satisfied
+error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String> {index}: HttpServiceFactory` is not satisfied
-  --> $DIR/route-unexpected-method-fail.rs:12:55
+   --> tests/trybuild/route-unexpected-method-fail.rs:12:55
     |
 12  |     let srv = actix_test::start(|| App::new().service(index));
-   |                                                       ^^^^^ the trait `HttpServiceFactory` is not implemented for `fn() -> impl std::future::Future {index}`
+    |                                               ------- ^^^^^ the trait `HttpServiceFactory` is not implemented for `fn() -> impl std::future::Future<Output = String> {index}`
+    |                                               |
+    |                                               required by a bound introduced by this call
+    |
+note: required by a bound in `App::<T>::service`
+   --> $WORKSPACE/actix-web/src/app.rs
+    |
+    |         F: HttpServiceFactory + 'static,
+    |            ^^^^^^^^^^^^^^^^^^ required by this bound in `App::<T>::service`

actix-web-codegen/tests/trybuild/routes-missing-args-fail.rs

@@ -0,0 +1,14 @@
+use actix_web_codegen::*;
+
+#[routes]
+#[get]
+async fn index() -> String {
+    "Hello World!".to_owned()
+}
+
+#[actix_web::main]
+async fn main() {
+    use actix_web::App;
+
+    let srv = actix_test::start(|| App::new().service(index));
+}

actix-web-codegen/tests/trybuild/routes-missing-args-fail.stderr

@@ -0,0 +1,27 @@
+error: invalid service definition, expected #[get("<path>")]
+ --> tests/trybuild/routes-missing-args-fail.rs:4:1
+  |
+4 | #[get]
+  | ^^^^^^
+  |
+  = note: this error originates in the attribute macro `get` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: Invalid input for macro
+ --> tests/trybuild/routes-missing-args-fail.rs:4:1
+  |
+4 | #[get]
+  | ^^^^^^
+
+error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String> {index}: HttpServiceFactory` is not satisfied
+   --> tests/trybuild/routes-missing-args-fail.rs:13:55
+    |
+13  |     let srv = actix_test::start(|| App::new().service(index));
+    |                                               ------- ^^^^^ the trait `HttpServiceFactory` is not implemented for `fn() -> impl std::future::Future<Output = String> {index}`
+    |                                               |
+    |                                               required by a bound introduced by this call
+    |
+note: required by a bound in `App::<T>::service`
+   --> $WORKSPACE/actix-web/src/app.rs
+    |
+    |         F: HttpServiceFactory + 'static,
+    |            ^^^^^^^^^^^^^^^^^^ required by this bound in `App::<T>::service`

actix-web-codegen/tests/trybuild/routes-missing-method-fail.rs

@@ -0,0 +1,13 @@
+use actix_web_codegen::*;
+
+#[routes]
+async fn index() -> String {
+    "Hello World!".to_owned()
+}
+
+#[actix_web::main]
+async fn main() {
+    use actix_web::App;
+
+    let srv = actix_test::start(|| App::new().service(index));
+}

actix-web-codegen/tests/trybuild/routes-missing-method-fail.stderr

@@ -0,0 +1,21 @@
+error: The #[routes] macro requires at least one `#[<method>(..)]` attribute.
+ --> tests/trybuild/routes-missing-method-fail.rs:3:1
+  |
+3 | #[routes]
+  | ^^^^^^^^^
+  |
+  = note: this error originates in the attribute macro `routes` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String> {index}: HttpServiceFactory` is not satisfied
+   --> tests/trybuild/routes-missing-method-fail.rs:12:55
+    |
+12  |     let srv = actix_test::start(|| App::new().service(index));
+    |                                               ------- ^^^^^ the trait `HttpServiceFactory` is not implemented for `fn() -> impl std::future::Future<Output = String> {index}`
+    |                                               |
+    |                                               required by a bound introduced by this call
+    |
+note: required by a bound in `App::<T>::service`
+   --> $WORKSPACE/actix-web/src/app.rs
+    |
+    |         F: HttpServiceFactory + 'static,
+    |            ^^^^^^^^^^^^^^^^^^ required by this bound in `App::<T>::service`

actix-web-codegen/tests/trybuild/routes-ok.rs

@@ -0,0 +1,23 @@
+use actix_web_codegen::*;
+
+#[routes]
+#[get("/")]
+#[post("/")]
+async fn index() -> String {
+    "Hello World!".to_owned()
+}
+
+#[actix_web::main]
+async fn main() {
+    use actix_web::App;
+
+    let srv = actix_test::start(|| App::new().service(index));
+
+    let request = srv.get("/");
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.post("/");
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}

actix-web/CHANGES.md

@@ -1,6 +1,53 @@
 # Changelog
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2022-xx-xx
+### Added
+- Add `ContentDisposition::attachment` constructor. [#2867]
+- Add `ErrorHandlers::default_handler()` (as well as `default_handler_{server, client}()`) to make registering handlers for groups of response statuses easier. [#2784]
+
+[#2784]: https://github.com/actix/actix-web/pull/2784
+[#2867]: https://github.com/actix/actix-web/pull/2867
+
+
+## 4.2.1 - 2022-09-12
+### Fixed
+- Bump minimum version of `actix-http` dependency to fix compatibility issue. [#2871]
+
+[#2871]: https://github.com/actix/actix-web/pull/2871
+
+
+## 4.2.0 - 2022-09-11
+### Added
+- Add `#[routes]` macro to support multiple paths for one handler. [#2718]
+- Add `ServiceRequest::{parts, request}()` getter methods. [#2786]
+- Add configuration options for TLS handshake timeout via `HttpServer::{rustls, openssl}_with_config` methods. [#2752]
+
+### Changed
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.
+
+[#2718]: https://github.com/actix/actix-web/pull/2718
+[#2752]: https://github.com/actix/actix-web/pull/2752
+[#2786]: https://github.com/actix/actix-web/pull/2786
+
+
+## 4.1.0 - 2022-06-11
+### Added
+- Add `ServiceRequest::extract()` to make it easier to use extractors when writing middlewares. [#2647]
+- Add `Route::wrap()` to allow individual routes to use middleware. [#2725]
+- Add `ServiceConfig::default_service()`. [#2338] [#2743]
+- Implement `ResponseError` for `std::convert::Infallible`
+
+### Changed
+- Minimum supported Rust version (MSRV) is now 1.56 due to transitive `hashbrown` dependency.
+
+### Fixed
+- Clear connection-level data on `HttpRequest` drop. [#2742]
+
+[#2338]: https://github.com/actix/actix-web/pull/2338
+[#2647]: https://github.com/actix/actix-web/pull/2647
+[#2725]: https://github.com/actix/actix-web/pull/2725
+[#2742]: https://github.com/actix/actix-web/pull/2742
+[#2743]: https://github.com/actix/actix-web/pull/2743
 
 ### Added
 

actix-web/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "4.0.1"
+version = "4.2.1"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Rob Ede <robjtede@icloud.com>",
@@ -59,7 +59,7 @@ rustls = ["actix-http/rustls", "actix-tls/accept", "actix-tls/rustls"]
 # Don't rely on these whatsoever. They may disappear at anytime.
 __compress = []
 
-# io-uring feature only avaiable for Linux OSes.
+# io-uring feature only available for Linux OSes.
 experimental-io-uring = ["actix-server/io-uring"]
 
 [dependencies]
@@ -71,24 +71,25 @@ actix-service = "2"
 actix-utils = "3"
 actix-tls = { version = "3", default-features = false, optional = true }
 
-actix-http = { version = "3", features = ["http2", "ws"] }
+actix-http = { version = "3.2.2", features = ["http2", "ws"] }
 actix-router = "0.5"
-actix-web-codegen = { version = "4", optional = true }
+actix-web-codegen = { version = "4.1", optional = true }
 
 ahash = "0.7"
 bytes = "1"
 bytestring = "1"
 cfg-if = "1"
 cookie = { version = "0.16", features = ["percent-encode"], optional = true }
-derive_more = "0.99.5"
+derive_more = "0.99.8"
 encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
+http = "0.2.8"
 itoa = "1"
 language-tags = "0.3"
-once_cell = "1.5"
 log = "0.4"
 mime = "0.3"
+once_cell = "1.5"
 pin-project-lite = "0.2.7"
 regex = "1.5.5"
 serde = "1.0"
@@ -101,24 +102,24 @@ url = "2.1"
 
 [dev-dependencies]
 actix-files = "0.6"
-actix-test = { version = "0.1.0-beta.13", features = ["openssl", "rustls"] }
+actix-test = { version = "0.1", features = ["openssl", "rustls"] }
 awc = { version = "3", features = ["openssl"] }
 
 brotli = "3.3.3"
-const-str = "0.3"
+const-str = "0.4"
 criterion = { version = "0.3", features = ["html_reports"] }
 env_logger = "0.9"
 flate2 = "1.0.13"
 futures-util = { version = "0.3.7", default-features = false, features = ["std"] }
 rand = "0.8"
-rcgen = "0.8"
+rcgen = "0.9"
-rustls-pemfile = "0.2"
+rustls-pemfile = "1"
 serde = { version = "1.0", features = ["derive"] }
 static_assertions = "1"
 tls-openssl = { package = "openssl", version = "0.10.9" }
 tls-rustls = { package = "rustls", version = "0.20.0" }
 tokio = { version = "1.13.1", features = ["rt-multi-thread", "macros"] }
-zstd = "0.10"
+zstd = "0.11"
 
 [[test]]
 name = "test_server"

actix-web/MIGRATION-4.0.md

@@ -31,6 +31,7 @@ Headings marked with :warning: are **breaking behavioral changes**. They will pr
 - [Returning `HttpResponse` synchronously](#returning-httpresponse-synchronously)
 - [`#[actix_web::main]` and `#[tokio::main]`](#actix_webmain-and-tokiomain)
 - [`web::block`](#webblock)
+- 
 
 ## MSRV
 
@@ -483,3 +484,24 @@ The `web::block` helper has changed return type from roughly `async fn(fn() -> R
 - let n: u32 = web::block(|| Ok(123)).await?;
 + let n: u32 = web::block(|| Ok(123)).await??;
 ```
+
+## `HttpResponse` as a `ResponseError`
+
+The implementation of `ResponseError` for `HttpResponse` has been removed.
+
+It was common in v3 to use `HttpResponse` as an error type in fallible handlers. The problem is that `HttpResponse` contains no knowledge or reference to the source error. Being able to guarantee that an "error" response actually contains an error reference makes middleware and other parts of Actix Web more effective.
+
+The error response builders in the `error` module were available in v3 but are now the best method for simple error responses without requiring you to implement the trait on your own custom error types. These builders can receive simple strings and third party errors that can not implement the `ResponseError` trait.
+
+A few common patterns are affected by this change:
+
+```diff
+- Err(HttpResponse::InternalServerError().finish())
++ Err(error::ErrorInternalServerError("reason"))
+
+- Err(HttpResponse::InternalServerError().body(third_party_error.to_string()))
++ Err(error::ErrorInternalServerError(err))
+
+- .map_err(|err| HttpResponse::InternalServerError().finish())?
++ .map_err(error::ErrorInternalServerError)?
+```

actix-web/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.1)](https://docs.rs/actix-web/4.0.1)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.2.1)](https://docs.rs/actix-web/4.2.1)
-![MSRV](https://img.shields.io/badge/rustc-1.54+-ab6000.svg)
+![MSRV](https://img.shields.io/badge/rustc-1.59+-ab6000.svg)
 ![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.1/status.svg)](https://deps.rs/crate/actix-web/4.0.1)
+[![Dependency Status](https://deps.rs/crate/actix-web/4.2.1/status.svg)](https://deps.rs/crate/actix-web/4.2.1)
 <br />
 [![CI](https://github.com/actix/actix-web/actions/workflows/ci.yml/badge.svg)](https://github.com/actix/actix-web/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web)
@@ -33,7 +33,7 @@
 - SSL support using OpenSSL or Rustls
 - Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
 - Integrates with the [`awc` HTTP client](https://docs.rs/awc/)
-- Runs on stable Rust 1.54+
+- Runs on stable Rust 1.59+
 
 ## Documentation
 
@@ -79,6 +79,7 @@ async fn main() -> std::io::Result<()> {
 - [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)
+- [MongoDB Integration](https://github.com/actix/examples/tree/master/databases/mongodb)
 - [Diesel Integration](https://github.com/actix/examples/tree/master/databases/diesel)
 - [SQLite Integration](https://github.com/actix/examples/tree/master/databases/sqlite)
 - [Postgres Integration](https://github.com/actix/examples/tree/master/databases/postgres)

actix-web/src/app.rs

@@ -60,7 +60,7 @@ where
     /// [`HttpRequest::app_data`](crate::HttpRequest::app_data) method at runtime.
     ///
     /// # [`Data<T>`]
-    /// Any [`Data<T>`] type added here can utilize it's extractor implementation in handlers.
+    /// Any [`Data<T>`] type added here can utilize its extractor implementation in handlers.
     /// Types not wrapped in `Data<T>` cannot use this extractor. See [its docs](Data<T>) for more
     /// about its usage and patterns.
     ///
@@ -185,10 +185,17 @@ where
         F: FnOnce(&mut ServiceConfig),
     {
         let mut cfg = ServiceConfig::new();
+
         f(&mut cfg);
+
         self.services.extend(cfg.services);
         self.external.extend(cfg.external);
         self.extensions.extend(cfg.app_data);
+
+        if let Some(default) = cfg.default {
+            self.default = Some(default);
+        }
+
         self
     }
 
@@ -267,7 +274,6 @@ where
     {
         let svc = svc
             .into_factory()
-            .map(|res| res.map_into_boxed_body())
             .map_init_err(|e| log::error!("Can not construct default service: {:?}", e));
 
         self.default = Some(Rc::new(boxed::factory(svc)));
@@ -308,7 +314,7 @@ where
 
     /// Registers an app-wide middleware.
     ///
-    /// Registers middleware, in the form of a middleware compo nen t (type), that runs during
+    /// Registers middleware, in the form of a middleware component (type), that runs during
     /// inbound and/or outbound processing in the request life-cycle (request -> response),
     /// modifying request/response as necessary, across all requests managed by the `App`.
     ///
@@ -676,7 +682,7 @@ mod tests {
                     "/test",
                     web::get().to(|req: HttpRequest| {
                         HttpResponse::Ok()
-                            .body(req.url_for("youtube", &["12345"]).unwrap().to_string())
+                            .body(req.url_for("youtube", ["12345"]).unwrap().to_string())
                     }),
                 ),
         )

actix-web/src/app_service.rs

@@ -173,7 +173,7 @@ impl AppInitServiceState {
 
     #[inline]
     pub(crate) fn rmap(&self) -> &ResourceMap {
-        &*self.rmap
+        &self.rmap
     }
 
     #[inline]
@@ -257,7 +257,7 @@ impl ServiceFactory<ServiceRequest> for AppRoutingFactory {
     type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        // construct all services factory future with it's resource def and guards.
+        // construct all services factory future with its resource def and guards.
         let factory_fut = join_all(self.services.iter().map(|(path, factory, guards)| {
             let path = path.clone();
             let guards = guards.borrow_mut().take().unwrap_or_default();

actix-web/src/config.rs

@@ -1,33 +1,32 @@
-use std::net::SocketAddr;
+use std::{net::SocketAddr, rc::Rc};
-use std::rc::Rc;
 
-use actix_http::Extensions;
+use actix_service::{boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt as _};
-use actix_router::ResourceDef;
-use actix_service::{boxed, IntoServiceFactory, ServiceFactory};
 
-use crate::data::Data;
+use crate::{
-use crate::error::Error;
+    data::Data,
-use crate::guard::Guard;
+    dev::{Extensions, ResourceDef},
-use crate::resource::Resource;
+    error::Error,
-use crate::rmap::ResourceMap;
+    guard::Guard,
-use crate::route::Route;
+    resource::Resource,
-use crate::service::{
+    rmap::ResourceMap,
-    AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, ServiceRequest,
+    route::Route,
-    ServiceResponse,
+    service::{
+        AppServiceFactory, BoxedHttpServiceFactory, HttpServiceFactory, ServiceFactoryWrapper,
+        ServiceRequest, ServiceResponse,
+    },
 };
 
 type Guards = Vec<Box<dyn Guard>>;
-type HttpNewService = boxed::BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
 
 /// Application configuration
 pub struct AppService {
     config: AppConfig,
     root: bool,
-    default: Rc<HttpNewService>,
+    default: Rc<BoxedHttpServiceFactory>,
     #[allow(clippy::type_complexity)]
     services: Vec<(
         ResourceDef,
-        HttpNewService,
+        BoxedHttpServiceFactory,
         Option<Guards>,
         Option<Rc<ResourceMap>>,
     )>,
@@ -35,7 +34,7 @@ pub struct AppService {
 
 impl AppService {
     /// Crate server settings instance.
-    pub(crate) fn new(config: AppConfig, default: Rc<HttpNewService>) -> Self {
+    pub(crate) fn new(config: AppConfig, default: Rc<BoxedHttpServiceFactory>) -> Self {
         AppService {
             config,
             default,
@@ -56,7 +55,7 @@ impl AppService {
         AppConfig,
         Vec<(
             ResourceDef,
-            HttpNewService,
+            BoxedHttpServiceFactory,
             Option<Guards>,
             Option<Rc<ResourceMap>>,
         )>,
@@ -81,7 +80,7 @@ impl AppService {
     }
 
     /// Returns default handler factory.
-    pub fn default_service(&self) -> Rc<HttpNewService> {
+    pub fn default_service(&self) -> Rc<BoxedHttpServiceFactory> {
         self.default.clone()
     }
 
@@ -154,6 +153,16 @@ impl AppConfig {
 }
 
 impl Default for AppConfig {
+    /// Returns the default AppConfig.
+    /// Note: The included socket address is "127.0.0.1".
+    ///
+    /// 127.0.0.1: non-routable meta address that denotes an unknown, invalid or non-applicable target.
+    /// If you need a service only accessed by itself, use a loopback address.
+    /// A loopback address for IPv4 is any loopback address that begins with "127".
+    /// Loopback addresses should be only used to test your application locally.
+    /// The default configuration provides a loopback address.
+    ///
+    /// 0.0.0.0: if configured to use this special address, the application will listen to any IP address configured on the machine.
     fn default() -> Self {
         AppConfig::new(
             false,
@@ -187,6 +196,7 @@ pub struct ServiceConfig {
     pub(crate) services: Vec<Box<dyn AppServiceFactory>>,
     pub(crate) external: Vec<ResourceDef>,
     pub(crate) app_data: Extensions,
+    pub(crate) default: Option<Rc<BoxedHttpServiceFactory>>,
 }
 
 impl ServiceConfig {
@@ -195,6 +205,7 @@ impl ServiceConfig {
             services: Vec::new(),
             external: Vec::new(),
             app_data: Extensions::new(),
+            default: None,
         }
     }
 
@@ -215,6 +226,29 @@ impl ServiceConfig {
         self
     }
 
+    /// Default service to be used if no matching resource could be found.
+    ///
+    /// Counterpart to [`App::default_service()`](crate::App::default_service).
+    pub fn default_service<F, U>(&mut self, f: F) -> &mut Self
+    where
+        F: IntoServiceFactory<U, ServiceRequest>,
+        U: ServiceFactory<
+                ServiceRequest,
+                Config = (),
+                Response = ServiceResponse,
+                Error = Error,
+            > + 'static,
+        U::InitError: std::fmt::Debug,
+    {
+        let svc = f
+            .into_factory()
+            .map_init_err(|err| log::error!("Can not construct default service: {:?}", err));
+
+        self.default = Some(Rc::new(boxed::factory(svc)));
+
+        self
+    }
+
     /// Run external configuration as part of the application building process
     ///
     /// Counterpart to [`App::configure()`](crate::App::configure) that allows for easy nesting.
@@ -310,7 +344,7 @@ mod tests {
                     "/test",
                     web::get().to(|req: HttpRequest| {
                         HttpResponse::Ok()
-                            .body(req.url_for("youtube", &["12345"]).unwrap().to_string())
+                            .body(req.url_for("youtube", ["12345"]).unwrap().to_string())
                     }),
                 ),
         )
@@ -322,6 +356,38 @@ mod tests {
         assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345"));
     }
 
+    #[actix_rt::test]
+    async fn registers_default_service() {
+        let srv = init_service(
+            App::new()
+                .configure(|cfg| {
+                    cfg.default_service(
+                        web::get().to(|| HttpResponse::NotFound().body("four oh four")),
+                    );
+                })
+                .service(web::scope("/scoped").configure(|cfg| {
+                    cfg.default_service(
+                        web::get().to(|| HttpResponse::NotFound().body("scoped four oh four")),
+                    );
+                })),
+        )
+        .await;
+
+        // app registers default service
+        let req = TestRequest::with_uri("/path/i/did/not-configure").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+        let body = read_body(resp).await;
+        assert_eq!(body, Bytes::from_static(b"four oh four"));
+
+        // scope registers default service
+        let req = TestRequest::with_uri("/scoped/path/i/did/not-configure").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+        let body = read_body(resp).await;
+        assert_eq!(body, Bytes::from_static(b"scoped four oh four"));
+    }
+
     #[actix_rt::test]
     async fn test_service() {
         let srv = init_service(App::new().configure(|cfg| {

actix-web/src/data.rs

@@ -5,10 +5,7 @@ use actix_utils::future::{err, ok, Ready};
 use futures_core::future::LocalBoxFuture;
 use serde::Serialize;
 
-use crate::{
+use crate::{dev::Payload, error, Error, FromRequest, HttpRequest};
-    dev::Payload, error::ErrorInternalServerError, extract::FromRequest, request::HttpRequest,
-    Error,
-};
 
 /// Data factory.
 pub(crate) trait DataFactory {
@@ -121,7 +118,7 @@ impl<T: ?Sized> Deref for Data<T> {
 
 impl<T: ?Sized> Clone for Data<T> {
     fn clone(&self) -> Data<T> {
-        Data(self.0.clone())
+        Data(Arc::clone(&self.0))
     }
 }
 
@@ -160,7 +157,7 @@ impl<T: ?Sized + 'static> FromRequest for Data<T> {
                 req.match_name().unwrap_or_else(|| req.path())
             );
 
-            err(ErrorInternalServerError(
+            err(error::ErrorInternalServerError(
                 "Requested application data is not configured correctly. \
                 View/enable debug logs for more details.",
             ))

actix-web/src/error/error.rs

@@ -51,12 +51,6 @@ impl StdError for Error {
     }
 }
 
-impl From<std::convert::Infallible> for Error {
-    fn from(val: std::convert::Infallible) -> Self {
-        match val {}
-    }
-}
-
 /// `Error` for any error that implements `ResponseError`
 impl<T: ResponseError + 'static> From<T> for Error {
     fn from(err: T) -> Error {

actix-web/src/error/mod.rs

@@ -42,7 +42,7 @@ pub struct BlockingError;
 impl ResponseError for crate::error::BlockingError {}
 
 /// Errors which can occur when attempting to generate resource uri.
-#[derive(Debug, PartialEq, Display, Error, From)]
+#[derive(Debug, PartialEq, Eq, Display, Error, From)]
 #[non_exhaustive]
 pub enum UrlGenerationError {
     /// Resource not found.

actix-web/src/error/response_error.rs

@@ -1,6 +1,7 @@
 //! `ResponseError` trait and foreign impls.
 
 use std::{
+    convert::Infallible,
     error::Error as StdError,
     fmt,
     io::{self, Write as _},
@@ -54,6 +55,15 @@ downcast_dyn!(ResponseError);
 
 impl ResponseError for Box<dyn StdError + 'static> {}
 
+impl ResponseError for Infallible {
+    fn status_code(&self) -> StatusCode {
+        match *self {}
+    }
+    fn error_response(&self) -> HttpResponse<BoxBody> {
+        match *self {}
+    }
+}
+
 #[cfg(feature = "openssl")]
 impl ResponseError for actix_tls::accept::openssl::reexports::Error {}