prepare actix-web release 4.3.0

prepare awc release 3.1.0
prepare actix-http release 3.3.0
2025-07-05 18:35:22 +02:00 · 2023-01-21 18:57:42 +00:00 · 2023-01-21 18:54:58 +00:00 · 2023-01-21 18:52:57 +00:00 · 2023-01-21 18:46:44 +00:00 · 2023-01-21 01:36:08 +00:00
134 changed files with 2391 additions and 749 deletions
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@ -5,6 +5,9 @@ on:
    branches:
      - master

+permissions:
+  contents: read  #  to fetch code (actions/checkout)
+
 jobs:
  check_benchmark:
    runs-on: ubuntu-latest
--- a/.github/workflows/ci-post-merge.yml
+++ b/.github/workflows/ci-post-merge.yml
@ -4,6 +4,9 @@ on:
  push:
    branches: [master]

+permissions:
+  contents: read  #  to fetch code (actions/checkout)
+
 jobs:
  build_and_test_nightly:
    strategy:
@ -92,29 +95,21 @@ jobs:
    steps:
      - uses: actions/checkout@v2

-      - name: Install stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
+      - uses: dtolnay/rust-toolchain@stable

      - name: Install cargo-hack
        uses: taiki-e/install-action@cargo-hack

      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
+        run: cargo generate-lockfile
      - name: Cache Dependencies
        uses: Swatinem/rust-cache@v1.2.0

      - name: check feature combinations
-        uses: actions-rs/cargo@v1
-        with: { command: ci-check-all-feature-powerset }
-      
+        run: cargo ci-check-all-feature-powerset
+
      - name: check feature combinations
-        uses: actions-rs/cargo@v1
-        with: { command: ci-check-all-feature-powerset-linux }
+        run: cargo ci-check-all-feature-powerset-linux

  nextest:
    name: nextest
@ -127,24 +122,15 @@ jobs:
    steps:
      - uses: actions/checkout@v2

-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
+      - uses: dtolnay/rust-toolchain@stable

      - name: Install nextest
        uses: taiki-e/install-action@nextest

      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
+        run: cargo generate-lockfile
      - name: Cache Dependencies
        uses: Swatinem/rust-cache@v1.3.0

      - name: Test with cargo-nextest
-        uses: actions-rs/cargo@v1
-        with:
-          command: nextest
-          args: run
+        run: cargo nextest run
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -6,6 +6,9 @@ on:
  push:
    branches: [master]

+permissions:
+  contents: read  #  to fetch code (actions/checkout)
+
 jobs:
  build_and_test:
    strategy:
@ -16,7 +19,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.57.0 # MSRV
+          - 1.59.0 # MSRV
          - stable

    name: ${{ matrix.target.name }} / ${{ matrix.version }}
@ -63,6 +66,11 @@ jobs:
      - name: Cache Dependencies
        uses: Swatinem/rust-cache@v1.2.0

+      - name: workaround MSRV issues
+        if: matrix.version != 'stable'
+        run: |
+          cargo update -p=zstd-sys --precise=2.0.1+zstd.1.5.2
+
      - name: check minimal
        uses: actions-rs/cargo@v1
        with: { command: ci-check-min }
@ -96,16 +104,10 @@ jobs:
    steps:
      - uses: actions/checkout@v2

-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
+      - uses: dtolnay/rust-toolchain@stable

      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
+        run: cargo generate-lockfile
      - name: Cache Dependencies
        uses: Swatinem/rust-cache@v1.3.0

@ -123,20 +125,13 @@ jobs:
    steps:
      - uses: actions/checkout@v2

-      - name: Install Rust (nightly)
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
+      - uses: dtolnay/rust-toolchain@nightly

      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
+        run: cargo generate-lockfile
      - name: Cache Dependencies
        uses: Swatinem/rust-cache@v1.3.0

      - name: doc tests
-        uses: actions-rs/cargo@v1
+        run: cargo ci-doctest
        timeout-minutes: 60
-        with: { command: ci-doctest }
--- a/.github/workflows/clippy-fmt.yml
+++ b/.github/workflows/clippy-fmt.yml
@ -9,54 +9,37 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          components: rustfmt
-      - name: Check with rustfmt
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+      - uses: dtolnay/rust-toolchain@nightly
+        with: { components: rustfmt }
+      - run: cargo fmt --all -- --check

  clippy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          components: clippy
-          override: true
+      - uses: dtolnay/rust-toolchain@stable
+        with: { components: clippy }

      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
+        run: cargo generate-lockfile
      - name: Cache Dependencies
        uses: Swatinem/rust-cache@v1.2.0
-
+  
      - name: Check with Clippy
        uses: actions-rs/clippy-check@v1
        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
          args: --workspace --tests --examples --all-features
+          token: ${{ secrets.GITHUB_TOKEN }}

  lint-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          components: rust-docs
+
+      - uses: dtolnay/rust-toolchain@stable
+        with: { components: rust-docs }
+
      - name: Check for broken intra-doc links
        uses: actions-rs/cargo@v1
        env:
--- a/.github/workflows/upload-doc.yml
+++ b/.github/workflows/upload-doc.yml
@ -4,32 +4,29 @@ on:
  push:
    branches: [master]

+permissions: {}
 jobs:
  build:
+    permissions:
+      contents: write  #  to push changes in repo (jamesives/github-pages-deploy-action)
+
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
+      - uses: dtolnay/rust-toolchain@nightly

      - name: Build Docs
-        uses: actions-rs/cargo@v1
-        with:
-          command: doc
-          args: --workspace --all-features --no-deps
+        run: cargo +nightly doc --no-deps --workspace --all-features
+        env:
+          RUSTDOCFLAGS: --cfg=docsrs

      - name: Tweak HTML
        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.1
        with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          BRANCH: gh-pages
-          FOLDER: target/doc
+          folder: target/doc
+          single-commit: true
--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@ -1,7 +1,11 @@
 # Changes

 ## Unreleased - 2022-xx-xx
+- XHTML files now use `Content-Disposition: inline` instead of `attachment`. [#2903]
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.
+- Update `tokio-uring` dependency to `0.4`.

+[#2903]: https://github.com/actix/actix-web/pull/2903

 ## 0.6.2 - 2022-07-23
 - Allow partial range responses for video content to start streaming sooner. [#2817]
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@ -3,7 +3,6 @@ name = "actix-files"
 version = "0.6.2"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
-    "fakeshadow <24548779@qq.com>",
    "Rob Ede <robjtede@icloud.com>",
 ]
 description = "Static file serving for Actix Web"
@ -27,22 +26,22 @@ 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"
-futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
+futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 http-range = "0.1.4"
 log = "0.4"
 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
 [target.'cfg(target_os = "linux")'.dependencies]
-tokio-uring = { version = "0.3", optional = true, features = ["bytes"] }
-actix-server = { version = "2.1", optional = true } # ensure matching tokio-uring versions
+tokio-uring = { version = "0.4", optional = true, features = ["bytes"] }
+actix-server = { version = "2.2", optional = true } # ensure matching tokio-uring versions

 [dev-dependencies]
 actix-rt = "2.7"
--- a/actix-files/README.md
+++ b/actix-files/README.md
@ -4,7 +4,7 @@

 [![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.2)](https://docs.rs/actix-files/0.6.2)
-![Version](https://img.shields.io/badge/rustc-1.57+-ab6000.svg)
+![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.2/status.svg)](https://deps.rs/crate/actix-files/0.6.2)
--- a/actix-files/src/directory.rs
+++ b/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())
    };
 }

--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
@ -13,6 +13,7 @@

 #![deny(rust_2018_idioms, nonstandard_style)]
 #![warn(future_incompatible, missing_docs, missing_debug_implementations)]
+#![allow(clippy::uninlined_format_args)]

 use actix_service::boxed::{BoxService, BoxServiceFactory};
 use actix_web::{
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@ -132,7 +132,7 @@ impl NamedFile {
                mime::IMAGE | mime::TEXT | mime::AUDIO | mime::VIDEO => DispositionType::Inline,
                mime::APPLICATION => match ct.subtype() {
                    mime::JAVASCRIPT | mime::JSON => DispositionType::Inline,
-                    name if name == "wasm" => DispositionType::Inline,
+                    name if name == "wasm" || name == "xhtml" => DispositionType::Inline,
                    _ => DispositionType::Attachment,
                },
                _ => DispositionType::Attachment,
--- a/actix-files/src/service.rs
+++ b/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
    }
 }

--- a/actix-http-test/CHANGES.md
+++ b/actix-http-test/CHANGES.md
@ -1,6 +1,7 @@
 # Changes

 ## Unreleased - 2022-xx-xx
+- Minimum supported Rust version (MSRV) is now 1.59.


 ## 3.0.0 - 2022-07-24
--- a/actix-http-test/Cargo.toml
+++ b/actix-http-test/Cargo.toml
@ -37,9 +37,8 @@ actix-rt = "2.2"
 actix-server = "2"
 awc = { version = "3", default-features = false }

-base64 = "0.13"
 bytes = "1"
-futures-core = { version = "0.3.7", default-features = false }
+futures-core = { version = "0.3.17", default-features = false }
 http = "0.2.5"
 log = "0.4"
 socket2 = "0.4"
@ -48,7 +47,7 @@ serde_json = "1.0"
 slab = "0.4"
 serde_urlencoded = "0.7"
 tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
-tokio = { version = "1.8.4", features = ["sync"] }
+tokio = { version = "1.18.4", features = ["sync"] }

 [dev-dependencies]
 actix-web = { version = "4", default-features = false, features = ["cookies"] }
--- a/actix-http-test/README.md
+++ b/actix-http-test/README.md
@ -4,7 +4,7 @@

 [![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)](https://docs.rs/actix-http-test/3.0.0)
-![Version](https://img.shields.io/badge/rustc-1.57+-ab6000.svg)
+![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/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0)
--- a/actix-http-test/src/lib.rs
+++ b/actix-http-test/src/lib.rs
@ -2,6 +2,7 @@

 #![deny(rust_2018_idioms, nonstandard_style)]
 #![warn(future_incompatible)]
+#![allow(clippy::uninlined_format_args)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]

@ -87,6 +88,7 @@ pub async fn test_server_with_addr<F: ServerServiceFactory<TcpStream>>(

        // notify TestServer that server and system have shut down
        // all thread managed resources should be dropped at this point
+        #[allow(clippy::let_underscore_future)]
        let _ = thread_stop_tx.send(());
    });

@ -294,6 +296,7 @@ impl Drop for TestServer {
        // without needing to await anything

        // signal server to stop
+        #[allow(clippy::let_underscore_future)]
        let _ = self.server.stop(true);

        // signal system to stop
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@ -3,6 +3,49 @@
 ## Unreleased - 2022-xx-xx


+## 3.3.0 - 2023-01-21
+### Added
+- Implement `MessageBody` for `Cow<'static, str>` and `Cow<'static, [u8]>`. [#2959]
+- Implement `MessageBody` for `&mut B` where `B: MessageBody + Unpin`. [#2868]
+- Implement `MessageBody` for `Pin<B>` where `B::Target: MessageBody`. [#2868]
+- Automatic h2c detection via new service finalizer `HttpService::tcp_auto_h2c()`. [#2957]
+- `HeaderMap::retain()` [#2955].
+- Header name constants in `header` module. [#2956] [#2968]
+  - `CACHE_STATUS`
+  - `CDN_CACHE_CONTROL`
+  - `CROSS_ORIGIN_EMBEDDER_POLICY`
+  - `CROSS_ORIGIN_OPENER_POLICY`
+  - `PERMISSIONS_POLICY`
+  - `X_FORWARDED_FOR`
+  - `X_FORWARDED_HOST`
+  - `X_FORWARDED_PROTO`
+
+### Fixed
+- Fix non-empty body of HTTP/2 HEAD responses. [#2920]
+
+### Performance
+- Improve overall performance of operations on `Extensions`. [#2890]
+
+[#2959]: https://github.com/actix/actix-web/pull/2959
+[#2868]: https://github.com/actix/actix-web/pull/2868
+[#2890]: https://github.com/actix/actix-web/pull/2890
+[#2920]: https://github.com/actix/actix-web/pull/2920
+[#2957]: https://github.com/actix/actix-web/pull/2957
+[#2955]: https://github.com/actix/actix-web/pull/2955
+[#2956]: https://github.com/actix/actix-web/pull/2956
+[#2968]: https://github.com/actix/actix-web/pull/2968
+
+
+## 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]
@ -29,9 +72,9 @@
 ### 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
-[#2624]: https://github.com/actix/actix-web/issues/2624
-[#2779]: https://github.com/actix/actix-web/issues/2779
+[#2779]: https://github.com/actix/actix-web/pull/2779


 ## 3.0.4 - 2022-03-09
@ -43,14 +86,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
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "3.2.1"
+version = "3.3.0"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
    "Rob Ede <robjtede@icloud.com>",
@ -67,7 +67,7 @@ bytes = "1"
 bytestring = "1"
 derive_more = "0.99.5"
 encoding_rs = "0.8"
-futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
+futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 http = "0.2.5"
 httparse = "1.5.1"
 httpdate = "1.0.1"
@ -77,6 +77,8 @@ mime = "0.3"
 percent-encoding = "2.1"
 pin-project-lite = "0.2"
 smallvec = "1.6.1"
+tokio = { version = "1.18.4", features = [] }
+tokio-util = { version = "0.7", features = ["io", "codec"] }
 tracing = { version = "0.1.30", default-features = false, features = ["log"] }

 # http2
@ -84,7 +86,7 @@ h2 = { version = "0.3.9", optional = true }

 # websockets
 local-channel = { version = "0.1", optional = true }
-base64 = { version = "0.13", optional = true }
+base64 = { version = "0.21", optional = true }
 rand = { version = "0.8", optional = true }
 sha1 = { version = "0.10", optional = true }

@ -94,7 +96,7 @@ 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.11", optional = true }
+zstd = { version = "0.12", optional = true }

 [dev-dependencies]
 actix-http-test = { version = "3", features = ["openssl"] }
@ -103,9 +105,9 @@ actix-tls = { version = "3", features = ["openssl"] }
 actix-web = "4"

 async-stream = "0.3"
-criterion = { version = "0.3", features = ["html_reports"] }
+criterion = { version = "0.4", features = ["html_reports"] }
 env_logger = "0.9"
-futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
+futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] }
 memchr = "2.4"
 once_cell = "1.9"
 rcgen = "0.9"
@ -117,7 +119,7 @@ serde_json = "1.0"
 static_assertions = "1"
 tls-openssl = { package = "openssl", version = "0.10.9" }
 tls-rustls = { package = "rustls", version = "0.20.0" }
-tokio = { version = "1.8.4", features = ["net", "rt", "macros"] }
+tokio = { version = "1.18.4", features = ["net", "rt", "macros"] }

 [[example]]
 name = "ws"
--- a/actix-http/README.md
+++ b/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.2.1)](https://docs.rs/actix-http/3.2.1)
-![Version](https://img.shields.io/badge/rustc-1.57+-ab6000.svg)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.3.0)](https://docs.rs/actix-http/3.3.0)
+![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.2.1/status.svg)](https://deps.rs/crate/actix-http/3.2.1)
+[![dependency status](https://deps.rs/crate/actix-http/3.3.0/status.svg)](https://deps.rs/crate/actix-http/3.3.0)
 [![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)

--- a/actix-http/benches/quality-value.rs
+++ b/actix-http/benches/quality-value.rs
@ -1,3 +1,5 @@
+#![allow(clippy::uninlined_format_args)]
+
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};

 const CODES: &[u16] = &[0, 1000, 201, 800, 550];
--- a/actix-http/examples/h2c-detect.rs
+++ b/actix-http/examples/h2c-detect.rs
@ -0,0 +1,29 @@
+//! An example that supports automatic selection of plaintext h1/h2c connections.
+//!
+//! Notably, both the following commands will work.
+//! ```console
+//! $ curl --http1.1 'http://localhost:8080/'
+//! $ curl --http2-prior-knowledge 'http://localhost:8080/'
+//! ```
+
+use std::{convert::Infallible, io};
+
+use actix_http::{HttpService, Request, Response, StatusCode};
+use actix_server::Server;
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    Server::build()
+        .bind("h2c-detect", ("127.0.0.1", 8080), || {
+            HttpService::build()
+                .finish(|_req: Request| async move {
+                    Ok::<_, Infallible>(Response::build(StatusCode::OK).body("Hello!"))
+                })
+                .tcp_auto_h2c()
+        })?
+        .workers(2)
+        .run()
+        .await
+}
--- a/actix-http/examples/ws.rs
+++ b/actix-http/examples/ws.rs
@ -10,13 +10,13 @@ use std::{
    time::Duration,
 };

-use actix_codec::Encoder;
 use actix_http::{body::BodyStream, error::Error, ws, HttpService, Request, Response};
 use actix_rt::time::{interval, Interval};
 use actix_server::Server;
 use bytes::{Bytes, BytesMut};
 use bytestring::ByteString;
 use futures_core::{ready, Stream};
+use tokio_util::codec::Encoder;
 use tracing::{info, trace};

 #[actix_rt::main]
--- a/actix-http/src/body/message_body.rs
+++ b/actix-http/src/body/message_body.rs
@ -120,8 +120,28 @@ pub trait MessageBody {
 }

 mod foreign_impls {
+    use std::{borrow::Cow, 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;
@ -303,6 +324,39 @@ mod foreign_impls {
        }
    }

+    impl MessageBody for Cow<'static, [u8]> {
+        type Error = Infallible;
+
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            if self.is_empty() {
+                Poll::Ready(None)
+            } else {
+                let bytes = match mem::take(self.get_mut()) {
+                    Cow::Borrowed(b) => Bytes::from_static(b),
+                    Cow::Owned(b) => Bytes::from(b),
+                };
+                Poll::Ready(Some(Ok(bytes)))
+            }
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            match self {
+                Cow::Borrowed(b) => Ok(Bytes::from_static(b)),
+                Cow::Owned(b) => Ok(Bytes::from(b)),
+            }
+        }
+    }
+
    impl MessageBody for &'static str {
        type Error = Infallible;

@ -358,6 +412,39 @@ mod foreign_impls {
        }
    }

+    impl MessageBody for Cow<'static, str> {
+        type Error = Infallible;
+
+        #[inline]
+        fn size(&self) -> BodySize {
+            BodySize::Sized(self.len() as u64)
+        }
+
+        #[inline]
+        fn poll_next(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+            if self.is_empty() {
+                Poll::Ready(None)
+            } else {
+                let bytes = match mem::take(self.get_mut()) {
+                    Cow::Borrowed(s) => Bytes::from_static(s.as_bytes()),
+                    Cow::Owned(s) => Bytes::from(s.into_bytes()),
+                };
+                Poll::Ready(Some(Ok(bytes)))
+            }
+        }
+
+        #[inline]
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
+            match self {
+                Cow::Borrowed(s) => Ok(Bytes::from_static(s.as_bytes())),
+                Cow::Owned(s) => Ok(Bytes::from(s.into_bytes())),
+            }
+        }
+    }
+
    impl MessageBody for bytestring::ByteString {
        type Error = Infallible;

@ -445,6 +532,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 +569,34 @@ 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() {
@ -607,4 +723,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"));
+    }
 }
--- a/actix-http/src/body/sized_stream.rs
+++ b/actix-http/src/body/sized_stream.rs
@ -44,7 +44,7 @@ where

    #[inline]
    fn size(&self) -> BodySize {
-        BodySize::Sized(self.size as u64)
+        BodySize::Sized(self.size)
    }

    /// Attempts to pull out the next value of the underlying [`Stream`].
--- a/actix-http/src/body/utils.rs
+++ b/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)),
        }
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@ -186,7 +186,7 @@ where
        self
    }

-    /// Finish service configuration and create a HTTP Service for HTTP/1 protocol.
+    /// Finish service configuration and create a service for the HTTP/1 protocol.
    pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B, X, U>
    where
        B: MessageBody,
@ -209,8 +209,9 @@ where
            .on_connect_ext(self.on_connect_ext)
    }

-    /// Finish service configuration and create a HTTP service for HTTP/2 protocol.
+    /// Finish service configuration and create a service for the 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>,
--- a/actix-http/src/config.rs
+++ b/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,
--- a/actix-http/src/error.rs
+++ b/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.
--- a/actix-http/src/extensions.rs
+++ b/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(),
        }
    }

--- a/actix-http/src/h1/chunked.rs
+++ b/actix-http/src/h1/chunked.rs
@ -71,7 +71,7 @@ impl ChunkedState {

        match size.checked_mul(radix) {
            Some(n) => {
-                *size = n as u64;
+                *size = n;
                *size += rem as u64;

                Poll::Ready(Ok(ChunkedState::Size))
--- a/actix-http/src/h1/client.rs
+++ b/actix-http/src/h1/client.rs
@ -1,9 +1,9 @@
 use std::{fmt, io};

-use actix_codec::{Decoder, Encoder};
 use bitflags::bitflags;
 use bytes::{Bytes, BytesMut};
 use http::{Method, Version};
+use tokio_util::codec::{Decoder, Encoder};

 use super::{
    decoder::{self, PayloadDecoder, PayloadItem, PayloadType},
--- a/actix-http/src/h1/codec.rs
+++ b/actix-http/src/h1/codec.rs
@ -1,9 +1,9 @@
 use std::{fmt, io};

-use actix_codec::{Decoder, Encoder};
 use bitflags::bitflags;
 use bytes::BytesMut;
 use http::{Method, Version};
+use tokio_util::codec::{Decoder, Encoder};

 use super::{
    decoder::{self, PayloadDecoder, PayloadItem, PayloadType},
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@ -8,13 +8,15 @@ use std::{
    task::{Context, Poll},
 };

-use actix_codec::{AsyncRead, AsyncWrite, Decoder as _, Encoder as _, Framed, FramedParts};
+use actix_codec::{Framed, FramedParts};
 use actix_rt::time::sleep_until;
 use actix_service::Service;
 use bitflags::bitflags;
 use bytes::{Buf, BytesMut};
 use futures_core::ready;
 use pin_project_lite::pin_project;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tokio_util::codec::{Decoder as _, Encoder as _};
 use tracing::{error, trace};

 use crate::{
@ -976,9 +978,11 @@ where
                //
                // A Request head too large to parse is only checked on `httparse::Status::Partial`.

-                if this.payload.is_none() {
-                    // When dispatcher has a payload the responsibility of wake up it would be shift
-                    // to h1::payload::Payload.
+                match this.payload {
+                    // When dispatcher has a payload the responsibility of wake ups is shifted to
+                    // `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
@ -989,7 +993,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);
@ -1001,7 +1006,7 @@ where
                this.read_buf.reserve(HW_BUFFER_SIZE - remaining);
            }

-            match actix_codec::poll_read_buf(io.as_mut(), cx, this.read_buf) {
+            match tokio_util::io::poll_read_buf(io.as_mut(), cx, this.read_buf) {
                Poll::Ready(Ok(n)) => {
                    this.flags.remove(Flags::FINISHED);

--- a/actix-http/src/h1/dispatcher_tests.rs
+++ b/actix-http/src/h1/dispatcher_tests.rs
@ -64,7 +64,7 @@ fn drop_payload_service(
 fn echo_payload_service() -> impl Service<Request, Response = Response<Bytes>, Error = Error> {
    fn_service(|mut req: Request| {
        Box::pin(async move {
-            use futures_util::stream::StreamExt as _;
+            use futures_util::StreamExt as _;

            let mut pl = req.take_payload();
            let mut body = BytesMut::new();
@ -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
--- a/actix-http/src/h1/encoder.rs
+++ b/actix-http/src/h1/encoder.rs
@ -450,7 +450,7 @@ impl TransferEncoding {

                    buf.extend_from_slice(&msg[..len as usize]);

-                    *remaining -= len as u64;
+                    *remaining -= len;
                    Ok(*remaining == 0)
                } else {
                    Ok(true)
--- a/actix-http/src/h1/service.rs
+++ b/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,
--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@ -29,7 +29,7 @@ use crate::{
        HeaderName, HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING, UPGRADE,
    },
    service::HttpFlow,
-    Extensions, OnConnectData, Payload, Request, Response, ResponseHead,
+    Extensions, Method, OnConnectData, Payload, Request, Response, ResponseHead,
 };

 const CHUNK_SIZE: usize = 16_384;
@ -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>>,
-    on_flight: bool,
+    /// Handle to send ping frames from the peer.
    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>
@ -113,6 +118,7 @@ where
                    let payload = crate::h2::Payload::new(body);
                    let pl = Payload::H2 { payload };
                    let mut req = Request::with_payload(pl);
+                    let head_req = parts.method == Method::HEAD;

                    let head = req.head_mut();
                    head.uri = parts.uri;
@ -130,10 +136,10 @@ where
                    actix_rt::spawn(async move {
                        // resolve service call and send response.
                        let res = match fut.await {
-                            Ok(res) => handle_response(res.into(), tx, config).await,
+                            Ok(res) => handle_response(res.into(), tx, config, head_req).await,
                            Err(err) => {
                                let res: Response<BoxBody> = err.into();
-                                handle_response(res, tx, config).await
+                                handle_response(res, tx, config, head_req).await
                            }
                        };

@ -152,26 +158,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 {
-                            // When have on flight ping pong. poll pong and and keep alive timer.
-                            // on success pong received update keep alive timer to determine the next timing of
-                            // ping pong.
+                        if ping_pong.in_flight {
+                            // When there is an in-flight ping-pong, poll pong and and keep-alive
+                            // timer. On successful pong received, update keep-alive timer to
+                            // determine the next timing of ping pong.
                            match ping_pong.ping_pong.poll_pong(cx)? {
                                Poll::Ready(_) => {
-                                    ping_pong.on_flight = false;
+                                    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
-                            // timing of ping pong. Therefore at this point it serves as an interval instead.
+                            // When there is no in-flight ping-pong, keep-alive timer is used to
+                            // wait for next timing of ping-pong. Therefore, at this point it serves
+                            // as an interval instead.
                            ready!(ping_pong.timer.as_mut().poll(cx));

                            ping_pong.ping_pong.send_ping(Ping::opaque())?;
@ -179,7 +187,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,
@ -199,6 +207,7 @@ async fn handle_response<B>(
    res: Response<B>,
    mut tx: SendResponse<Bytes>,
    config: ServiceConfig,
+    head_req: bool,
 ) -> Result<(), DispatchError>
 where
    B: MessageBody,
@ -208,14 +217,14 @@ where
    // prepare response.
    let mut size = body.size();
    let res = prepare_response(config, res.head(), &mut size);
-    let eof = size.is_eof();
+    let eof_or_head = size.is_eof() || head_req;

    // send response head and return on eof.
    let mut stream = tx
-        .send_response(res, eof)
+        .send_response(res, eof_or_head)
        .map_err(DispatchError::SendResponse)?;

-    if eof {
+    if eof_or_head {
        return Ok(());
    }

@ -287,13 +296,13 @@ fn prepare_response(
        _ => {}
    }

-    let _ = match size {
-        BodySize::None | BodySize::Stream => None,
+    match size {
+        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 +311,7 @@ fn prepare_response(
            res.headers_mut().insert(
                CONTENT_LENGTH,
                HeaderValue::from_str(buf.format(*len)).unwrap(),
-            )
+            );
        }
    };

--- a/actix-http/src/h2/service.rs
+++ b/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,
--- a/actix-http/src/header/common.rs
+++ b/actix-http/src/header/common.rs
@ -0,0 +1,51 @@
+//! Common header names not defined in [`http`].
+//!
+//! Any headers added to this file will need to be re-exported from the list at `crate::headers`.
+
+use http::header::HeaderName;
+
+/// Response header field that indicates how caches have handled that response and its corresponding
+/// request.
+///
+/// See [RFC 9211](https://www.rfc-editor.org/rfc/rfc9211) for full semantics.
+pub const CACHE_STATUS: HeaderName = HeaderName::from_static("cache-status");
+
+/// Response header field that allows origin servers to control the behavior of CDN caches
+/// interposed between them and clients separately from other caches that might handle the response.
+///
+/// See [RFC 9213](https://www.rfc-editor.org/rfc/rfc9213) for full semantics.
+pub const CDN_CACHE_CONTROL: HeaderName = HeaderName::from_static("cdn-cache-control");
+
+/// Response header that prevents a document from loading any cross-origin resources that don't
+/// explicitly grant the document permission (using [CORP] or [CORS]).
+///
+/// [CORP]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Cross-Origin_Resource_Policy_(CORP)
+/// [CORS]: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
+pub const CROSS_ORIGIN_EMBEDDER_POLICY: HeaderName =
+    HeaderName::from_static("cross-origin-embedder-policy");
+
+/// Response header that allows you to ensure a top-level document does not share a browsing context
+/// group with cross-origin documents.
+pub const CROSS_ORIGIN_OPENER_POLICY: HeaderName =
+    HeaderName::from_static("cross-origin-opener-policy");
+
+/// Response header that conveys a desire that the browser blocks no-cors cross-origin/cross-site
+/// requests to the given resource.
+pub const CROSS_ORIGIN_RESOURCE_POLICY: HeaderName =
+    HeaderName::from_static("cross-origin-resource-policy");
+
+/// Response header that provides a mechanism to allow and deny the use of browser features in a
+/// document or within any `<iframe>` elements in the document.
+pub const PERMISSIONS_POLICY: HeaderName = HeaderName::from_static("permissions-policy");
+
+/// Request header (de-facto standard) for identifying the originating IP address of a client
+/// connecting to a web server through a proxy server.
+pub const X_FORWARDED_FOR: HeaderName = HeaderName::from_static("x-forwarded-for");
+
+/// Request header (de-facto standard) for identifying the original host requested by the client in
+/// the `Host` HTTP request header.
+pub const X_FORWARDED_HOST: HeaderName = HeaderName::from_static("x-forwarded-host");
+
+/// Request header (de-facto standard) for identifying the protocol that a client used to connect to
+/// your proxy or load balancer.
+pub const X_FORWARDED_PROTO: HeaderName = HeaderName::from_static("x-forwarded-proto");
--- a/actix-http/src/header/map.rs
+++ b/actix-http/src/header/map.rs
@ -150,9 +150,7 @@ impl HeaderMap {
    /// assert_eq!(map.len(), 3);
    /// ```
    pub fn len(&self) -> usize {
-        self.inner
-            .iter()
-            .fold(0, |acc, (_, values)| acc + values.len())
+        self.inner.values().map(|vals| vals.len()).sum()
    }

    /// Returns the number of _keys_ stored in the map.
@ -309,7 +307,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(),
        }
    }

@ -552,6 +550,39 @@ impl HeaderMap {
        Keys(self.inner.keys())
    }

+    /// Retains only the headers specified by the predicate.
+    ///
+    /// In other words, removes all headers `(name, val)` for which `retain_fn(&name, &mut val)`
+    /// returns false.
+    ///
+    /// The order in which headers are visited should be considered arbitrary.
+    ///
+    /// # Examples
+    /// ```
+    /// # use actix_http::header::{self, HeaderMap, HeaderValue};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// map.append(header::HOST, HeaderValue::from_static("duck.com"));
+    /// map.append(header::SET_COOKIE, HeaderValue::from_static("one=1"));
+    /// map.append(header::SET_COOKIE, HeaderValue::from_static("two=2"));
+    ///
+    /// map.retain(|name, val| val.as_bytes().starts_with(b"one"));
+    ///
+    /// assert_eq!(map.len(), 1);
+    /// assert!(map.contains_key(&header::SET_COOKIE));
+    /// ```
+    pub fn retain<F>(&mut self, mut retain_fn: F)
+    where
+        F: FnMut(&HeaderName, &mut HeaderValue) -> bool,
+    {
+        self.inner.retain(|name, vals| {
+            vals.inner.retain(|val| retain_fn(name, val));
+
+            // invariant: make sure newly empty value lists are removed
+            !vals.is_empty()
+        })
+    }
+
    /// Clears the map, returning all name-value sets as an iterator.
    ///
    /// Header names will only be yielded for the first value in each set. All items that are
@ -943,6 +974,55 @@ mod tests {
        assert!(map.is_empty());
    }

+    #[test]
+    fn retain() {
+        let mut map = HeaderMap::new();
+
+        map.append(header::LOCATION, HeaderValue::from_static("/test"));
+        map.append(header::HOST, HeaderValue::from_static("duck.com"));
+        map.append(header::COOKIE, HeaderValue::from_static("one=1"));
+        map.append(header::COOKIE, HeaderValue::from_static("two=2"));
+
+        assert_eq!(map.len(), 4);
+
+        // by value
+        map.retain(|_, val| !val.as_bytes().contains(&b'/'));
+        assert_eq!(map.len(), 3);
+
+        // by name
+        map.retain(|name, _| name.as_str() != "cookie");
+        assert_eq!(map.len(), 1);
+
+        // keep but mutate value
+        map.retain(|_, val| {
+            *val = HeaderValue::from_static("replaced");
+            true
+        });
+        assert_eq!(map.len(), 1);
+        assert_eq!(map.get("host").unwrap(), "replaced");
+    }
+
+    #[test]
+    fn retain_removes_empty_value_lists() {
+        let mut map = HeaderMap::with_capacity(3);
+
+        map.append(header::HOST, HeaderValue::from_static("duck.com"));
+        map.append(header::HOST, HeaderValue::from_static("duck.com"));
+
+        assert_eq!(map.len(), 2);
+        assert_eq!(map.len_keys(), 1);
+        assert_eq!(map.inner.len(), 1);
+        assert_eq!(map.capacity(), 3);
+
+        // remove everything
+        map.retain(|_n, _v| false);
+
+        assert_eq!(map.len(), 0);
+        assert_eq!(map.len_keys(), 0);
+        assert_eq!(map.inner.len(), 0);
+        assert_eq!(map.capacity(), 3);
+    }
+
    #[test]
    fn entries_into_iter() {
        let mut map = HeaderMap::new();
--- a/actix-http/src/header/mod.rs
+++ b/actix-http/src/header/mod.rs
@ -1,14 +1,18 @@
 //! Pre-defined `HeaderName`s, traits for parsing and conversion, and other header utility methods.

+// declaring new header consts will yield this error
+#![allow(clippy::declare_interior_mutable_const)]
+
 use percent_encoding::{AsciiSet, CONTROLS};

 // re-export from http except header map related items
-pub use http::header::{
+pub use ::http::header::{
    HeaderName, HeaderValue, InvalidHeaderName, InvalidHeaderValue, ToStrError,
 };

-// re-export const header names
-pub use http::header::{
+// re-export const header names, list is explicit so that any updates to `common` module do not
+// conflict with this set
+pub use ::http::header::{
    ACCEPT, ACCEPT_CHARSET, ACCEPT_ENCODING, ACCEPT_LANGUAGE, ACCEPT_RANGES,
    ACCESS_CONTROL_ALLOW_CREDENTIALS, ACCESS_CONTROL_ALLOW_HEADERS,
    ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN, ACCESS_CONTROL_EXPOSE_HEADERS,
@ -30,22 +34,30 @@ pub use http::header::{
 use crate::{error::ParseError, HttpMessage};

 mod as_name;
+mod common;
 mod into_pair;
 mod into_value;
 pub mod map;
 mod shared;
 mod utils;

-pub use self::as_name::AsHeaderName;
-pub use self::into_pair::TryIntoHeaderPair;
-pub use self::into_value::TryIntoHeaderValue;
-pub use self::map::HeaderMap;
-pub use self::shared::{
-    parse_extended_value, q, Charset, ContentEncoding, ExtendedValue, HttpDate, LanguageTag,
-    Quality, QualityItem,
+pub use self::{
+    as_name::AsHeaderName,
+    into_pair::TryIntoHeaderPair,
+    into_value::TryIntoHeaderValue,
+    map::HeaderMap,
+    shared::{
+        parse_extended_value, q, Charset, ContentEncoding, ExtendedValue, HttpDate,
+        LanguageTag, Quality, QualityItem,
+    },
+    utils::{fmt_comma_delimited, from_comma_delimited, from_one_raw_str, http_percent_encode},
 };
-pub use self::utils::{
-    fmt_comma_delimited, from_comma_delimited, from_one_raw_str, http_percent_encode,
+
+// re-export list is explicit so that any updates to `http` do not conflict with this set
+pub use self::common::{
+    CACHE_STATUS, CDN_CACHE_CONTROL, CROSS_ORIGIN_EMBEDDER_POLICY, CROSS_ORIGIN_OPENER_POLICY,
+    CROSS_ORIGIN_RESOURCE_POLICY, PERMISSIONS_POLICY, X_FORWARDED_FOR, X_FORWARDED_HOST,
+    X_FORWARDED_PROTO,
 };

 /// An interface for types that already represent a valid header.
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@ -21,7 +21,8 @@
 #![allow(
    clippy::type_complexity,
    clippy::too_many_arguments,
-    clippy::borrow_interior_mutable_const
+    clippy::borrow_interior_mutable_const,
+    clippy::uninlined_format_args
 )]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
@ -40,6 +41,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;
@ -54,6 +56,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;
@ -71,6 +74,7 @@ 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.
--- a/actix-http/src/requests/request.rs
+++ b/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.
--- a/actix-http/src/responses/response.rs
+++ b/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.
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@ -24,7 +24,39 @@ use crate::{
    h1, ConnectCallback, OnConnectData, Protocol, Request, Response, ServiceConfig,
 };

-/// A `ServiceFactory` for HTTP/1.1 or HTTP/2 protocol.
+/// A [`ServiceFactory`] for HTTP/1.1 and HTTP/2 connections.
+///
+/// Use [`build`](Self::build) to begin constructing service. Also see [`HttpServiceBuilder`].
+///
+/// # Automatic HTTP Version Selection
+/// There are two ways to select the HTTP version of an incoming connection:
+/// - One is to rely on the ALPN information that is provided when using a TLS (HTTPS); both
+///   versions are supported automatically when using either of the `.rustls()` or `.openssl()`
+///   finalizing methods.
+/// - The other is to read the first few bytes of the TCP stream. This is the only viable approach
+///   for supporting H2C, which allows the HTTP/2 protocol to work over plaintext connections. Use
+///   the `.tcp_auto_h2c()` finalizing method to enable this behavior.
+///
+/// # Examples
+/// ```
+/// # use std::convert::Infallible;
+/// use actix_http::{HttpService, Request, Response, StatusCode};
+///
+/// // this service would constructed in an actix_server::Server
+///
+/// # actix_rt::System::new().block_on(async {
+/// HttpService::build()
+///     // the builder finalizing method, other finalizers would not return an `HttpService`
+///     .finish(|_req: Request| async move {
+///         Ok::<_, Infallible>(
+///             Response::build(StatusCode::OK).body("Hello!")
+///         )
+///     })
+///     // the service finalizing method method
+///     // you can use `.tcp_auto_h2c()`, `.rustls()`, or `.openssl()` instead of `.tcp()`
+///     .tcp();
+/// # })
+/// ```
 pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler> {
    srv: S,
    cfg: ServiceConfig,
@ -163,7 +195,9 @@ where
    U::Error: fmt::Display + Into<Response<BoxBody>>,
    U::InitError: fmt::Debug,
 {
-    /// Create simple tcp stream service
+    /// Creates TCP stream service from HTTP service.
+    ///
+    /// The resulting service only supports HTTP/1.x.
    pub fn tcp(
        self,
    ) -> impl ServiceFactory<
@ -179,6 +213,42 @@ where
        })
        .and_then(self)
    }
+
+    /// Creates TCP stream service from HTTP service that automatically selects HTTP/1.x or HTTP/2
+    /// on plaintext connections.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub fn tcp_auto_h2c(
+        self,
+    ) -> impl ServiceFactory<
+        TcpStream,
+        Config = (),
+        Response = (),
+        Error = DispatchError,
+        InitError = (),
+    > {
+        fn_service(move |io: TcpStream| async move {
+            // subset of HTTP/2 preface defined by RFC 9113 §3.4
+            // this subset was chosen to maximize likelihood that peeking only once will allow us to
+            // reliably determine version or else it should fallback to h1 and fail quickly if data
+            // on the wire is junk
+            const H2_PREFACE: &[u8] = b"PRI * HTTP/2";
+
+            let mut buf = [0; 12];
+
+            io.peek(&mut buf).await?;
+
+            let proto = if buf == H2_PREFACE {
+                Protocol::Http2
+            } else {
+                Protocol::Http1
+            };
+
+            let peer_addr = io.peer_addr().ok();
+            Ok((io, proto, peer_addr))
+        })
+        .and_then(self)
+    }
 }

 /// Configuration options used when accepting TLS connection.
@ -239,6 +309,7 @@ mod openssl {
        U::InitError: fmt::Debug,
    {
        /// Create OpenSSL based service.
+        #[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
        pub fn openssl(
            self,
            acceptor: SslAcceptor,
@ -253,6 +324,7 @@ mod openssl {
        }

        /// Create OpenSSL based service with custom TLS acceptor configuration.
+        #[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
        pub fn openssl_with_config(
            self,
            acceptor: SslAcceptor,
@ -332,6 +404,7 @@ mod rustls {
        U::InitError: fmt::Debug,
    {
        /// Create Rustls based service.
+        #[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
        pub fn rustls(
            self,
            config: ServerConfig,
@ -346,6 +419,7 @@ mod rustls {
        }

        /// 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,
--- a/actix-http/src/ws/codec.rs
+++ b/actix-http/src/ws/codec.rs
@ -1,7 +1,7 @@
-use actix_codec::{Decoder, Encoder};
 use bitflags::bitflags;
 use bytes::{Bytes, BytesMut};
 use bytestring::ByteString;
+use tokio_util::codec::{Decoder, Encoder};
 use tracing::error;

 use super::{
--- a/actix-http/src/ws/dispatcher.rs
+++ b/actix-http/src/ws/dispatcher.rs
@ -76,7 +76,9 @@ mod inner {
    use pin_project_lite::pin_project;
    use tracing::debug;

-    use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+    use actix_codec::Framed;
+    use tokio::io::{AsyncRead, AsyncWrite};
+    use tokio_util::codec::{Decoder, Encoder};

    use crate::{body::BoxBody, Response};

--- a/actix-http/src/ws/frame.rs
+++ b/actix-http/src/ws/frame.rs
@ -313,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());

@ -326,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());

@ -340,9 +340,9 @@ mod tests {
    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]);
+        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]);
+        buf.extend([0b0000_0010u8, 0b0000_0010u8, 0b1111_1111u8, 0b1111_1111u8]);

        assert_eq!(buf.len(), 8);
        assert!(matches!(
--- a/actix-http/src/ws/proto.rs
+++ b/actix-http/src/ws/proto.rs
@ -3,6 +3,7 @@ use std::{
    fmt,
 };

+use base64::prelude::*;
 use tracing::error;

 /// Operation codes defined in [RFC 6455 §11.8].
@ -244,7 +245,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_STANDARD.encode_slice(hash, &mut hash_b64).unwrap();
    assert_eq!(n, 28);

    hash_b64
--- a/actix-http/tests/test_openssl.rs
+++ b/actix-http/tests/test_openssl.rs
@ -1,4 +1,5 @@
 #![cfg(feature = "openssl")]
+#![allow(clippy::uninlined_format_args)]

 extern crate tls_openssl as openssl;

@ -16,7 +17,7 @@ use actix_utils::future::{err, ok, ready};
 use bytes::{Bytes, BytesMut};
 use derive_more::{Display, Error};
 use futures_core::Stream;
-use futures_util::stream::{once, StreamExt as _};
+use futures_util::{stream::once, StreamExt as _};
 use openssl::{
    pkey::PKey,
    ssl::{SslAcceptor, SslMethod},
--- a/actix-http/tests/test_rustls.rs
+++ b/actix-http/tests/test_rustls.rs
@ -1,4 +1,5 @@
 #![cfg(feature = "rustls")]
+#![allow(clippy::uninlined_format_args)]

 extern crate tls_rustls as rustls;

@ -41,7 +42,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)),
        }
--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@ -1,3 +1,5 @@
+#![allow(clippy::uninlined_format_args)]
+
 use std::{
    convert::Infallible,
    io::{Read, Write},
@ -7,18 +9,15 @@ use std::{

 use actix_http::{
    body::{self, BodyStream, BoxBody, SizedStream},
-    header, Error, HttpService, KeepAlive, Request, Response, StatusCode,
+    header, Error, HttpService, KeepAlive, Request, Response, StatusCode, Version,
 };
 use actix_http_test::test_server;
-use actix_rt::time::sleep;
+use actix_rt::{net::TcpStream, time::sleep};
 use actix_service::fn_service;
 use actix_utils::future::{err, ok, ready};
 use bytes::Bytes;
 use derive_more::{Display, Error};
-use futures_util::{
-    stream::{once, StreamExt as _},
-    FutureExt as _,
-};
+use futures_util::{stream::once, FutureExt as _, StreamExt as _};
 use regex::Regex;

 #[actix_rt::test]
@ -858,3 +857,44 @@ async fn not_modified_spec_h1() {

    srv.stop().await;
 }
+
+#[actix_rt::test]
+async fn h2c_auto() {
+    let mut srv = test_server(|| {
+        HttpService::build()
+            .keep_alive(KeepAlive::Disabled)
+            .finish(|req: Request| {
+                let body = match req.version() {
+                    Version::HTTP_11 => "h1",
+                    Version::HTTP_2 => "h2",
+                    _ => unreachable!(),
+                };
+                ok::<_, Infallible>(Response::ok().set_body(body))
+            })
+            .tcp_auto_h2c()
+    })
+    .await;
+
+    let req = srv.get("/");
+    assert_eq!(req.get_version(), &Version::HTTP_11);
+    let mut res = req.send().await.unwrap();
+    assert!(res.status().is_success());
+    assert_eq!(res.body().await.unwrap(), &b"h1"[..]);
+
+    // awc doesn't support forcing the version to http/2 so use h2 manually
+
+    let tcp = TcpStream::connect(srv.addr()).await.unwrap();
+    let (h2, connection) = h2::client::handshake(tcp).await.unwrap();
+    tokio::spawn(async move { connection.await.unwrap() });
+    let mut h2 = h2.ready().await.unwrap();
+
+    let request = ::http::Request::new(());
+    let (response, _) = h2.send_request(request, true).unwrap();
+    let (head, mut body) = response.await.unwrap().into_parts();
+    let body = body.data().await.unwrap().unwrap();
+
+    assert!(head.status.is_success());
+    assert_eq!(body, &b"h2"[..]);
+
+    srv.stop().await;
+}
--- a/actix-http/tests/test_ws.rs
+++ b/actix-http/tests/test_ws.rs
@ -1,3 +1,5 @@
+#![allow(clippy::uninlined_format_args)]
+
 use std::{
    cell::Cell,
    convert::Infallible,
--- a/actix-multipart/CHANGES.md
+++ b/actix-multipart/CHANGES.md
@ -1,7 +1,10 @@
 # Changes

 ## Unreleased - 2022-xx-xx
- Minimum supported Rust version (MSRV) is now 1.57 due to transitive `time` dependency.
+- 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
--- a/actix-multipart/Cargo.toml
+++ b/actix-multipart/Cargo.toml
@ -19,16 +19,16 @@ actix-web = { version = "4", default-features = false }

 bytes = "1"
 derive_more = "0.99.5"
-futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
+futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 httparse = "1.3"
 local-waker = "0.1"
 log = "0.4"
 mime = "0.3"
-twoway = "0.2"
+memchr = "2.5"

 [dev-dependencies]
 actix-rt = "2.2"
-actix-http = "3.0.0"
-futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
-tokio = { version = "1.8.4", features = ["sync"] }
+actix-http = "3"
+futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] }
+tokio = { version = "1.18.4", features = ["sync"] }
 tokio-stream = "0.1"
--- a/actix-multipart/README.md
+++ b/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.57+-ab6000.svg)
+![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)
--- a/actix-multipart/src/extractor.rs
+++ b/actix-multipart/src/extractor.rs
@ -14,7 +14,7 @@ use crate::server::Multipart;
 /// ```
 /// use actix_web::{web, HttpResponse, Error};
 /// use actix_multipart::Multipart;
-/// use futures_util::stream::StreamExt as _;
+/// use futures_util::StreamExt as _;
 ///
 /// async fn index(mut payload: Multipart) -> Result<HttpResponse, Error> {
 ///     // iterate over multipart stream
--- a/actix-multipart/src/lib.rs
+++ b/actix-multipart/src/lib.rs
@ -2,7 +2,7 @@

 #![deny(rust_2018_idioms, nonstandard_style)]
 #![warn(future_incompatible)]
-#![allow(clippy::borrow_interior_mutable_const)]
+#![allow(clippy::borrow_interior_mutable_const, clippy::uninlined_format_args)]

 mod error;
 mod extractor;
--- a/actix-multipart/src/server.rs
+++ b/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(
-                            &mut *payload,
-                            &self.boundary,
-                        )? {
+                        match InnerMultipart::skip_until_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,17 +359,18 @@ 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())
-                .unwrap_or(mime::APPLICATION_OCTET_STREAM);
+                .and_then(|ct| ct.parse().ok());

            self.state = InnerState::Boundary;

            // nested multipart stream is not supported
-            if ct.type_() == mime::MULTIPART {
-                return Poll::Ready(Some(Err(MultipartError::Nested)));
+            if let Some(mime) = &ct {
+                if mime.type_() == mime::MULTIPART {
+                    return Poll::Ready(Some(Err(MultipartError::Nested)));
+                }
            }

            let field =
@ -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.
-    pub fn content_type(&self) -> &mime::Mime {
-        &self.ct
+    /// Returns a reference to the field's content (mime) type, if it is supplied by the client.
+    ///
+    /// 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() {
@ -599,7 +606,7 @@ impl InnerField {
        }

        loop {
-            return if let Some(idx) = twoway::find_bytes(&payload.buf[pos..], b"\r") {
+            return if let Some(idx) = memchr::memmem::find(&payload.buf[pos..], b"\r") {
                let cur = pos + idx;

                // check if we have enough data for boundary detection
@ -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 {
@ -820,7 +827,7 @@ impl PayloadBuffer {

    /// Read until specified ending
    fn read_until(&mut self, line: &[u8]) -> Result<Option<Bytes>, MultipartError> {
-        let res = twoway::find_bytes(&self.buf, line)
+        let res = memchr::memmem::find(&self.buf, line)
            .map(|idx| self.buf.split_to(idx + line.len()).freeze());

        if res.is_none() && self.eof {
@ -861,7 +868,7 @@ mod tests {
    use actix_web::test::TestRequest;
    use actix_web::FromRequest;
    use bytes::Bytes;
-    use futures_util::{future::lazy, StreamExt};
+    use futures_util::{future::lazy, StreamExt as _};
    use std::time::Duration;
    use tokio::sync::mpsc;
    use tokio_stream::wrappers::UnboundedReceiverStream;
@ -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().subtype(), mime::PLAIN);
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
+                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().subtype(), mime::PLAIN);
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
+                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().subtype(), mime::PLAIN);
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
+                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().subtype(), mime::PLAIN);
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);

                assert_eq!(get_whole_field(&mut field).await, "data");
            }
--- a/actix-router/CHANGES.md
+++ b/actix-router/CHANGES.md
@ -1,7 +1,13 @@
 # Changes

 ## Unreleased - 2022-xx-xx
- Minimum supported Rust version (MSRV) is now 1.57 due to transitive `time` dependency.
+
+
+## 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
--- a/actix-router/Cargo.toml
+++ b/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>",
@ -27,7 +27,7 @@ serde = "1"
 tracing = { version = "0.1.30", default-features = false, features = ["log"] }

 [dev-dependencies]
-criterion = { version = "0.3", features = ["html_reports"] }
+criterion = { version = "0.4", features = ["html_reports"] }
 http = "0.2.5"
 serde = { version = "1", features = ["derive"] }
 percent-encoding = "2.1"
--- a/actix-router/benches/quoter.rs
+++ b/actix-router/benches/quoter.rs
@ -1,3 +1,5 @@
+#![allow(clippy::uninlined_format_args)]
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion};

 use std::borrow::Cow;
--- a/actix-router/src/de.rs
+++ b/actix-router/src/de.rs
@ -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");
--- a/actix-router/src/lib.rs
+++ b/actix-router/src/lib.rs
@ -2,6 +2,7 @@

 #![deny(rust_2018_idioms, nonstandard_style)]
 #![warn(future_incompatible)]
+#![allow(clippy::uninlined_format_args)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]

--- a/actix-router/src/path.rs
+++ b/actix-router/src/path.rs
@ -242,6 +242,7 @@ mod tests {

    use super::*;

+    #[allow(clippy::needless_borrow)]
    #[test]
    fn deref_impls() {
        let mut foo = Path::new("/foo");
--- a/actix-router/src/resource.rs
+++ b/actix-router/src/resource.rs
@ -1503,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()));
@ -1604,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();
--- a/actix-test/CHANGES.md
+++ b/actix-test/CHANGES.md
@ -1,6 +1,7 @@
 # Changes

 ## Unreleased - 2022-xx-xx
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.


 ## 0.1.0 - 2022-07-24
--- a/actix-test/Cargo.toml
+++ b/actix-test/Cargo.toml
@ -37,12 +37,12 @@ actix-utils = "3"
 actix-web = { version = "4", default-features = false, features = ["cookies"] }
 awc = { version = "3", default-features = false, features = ["cookies"] }

-futures-core = { version = "0.3.7", default-features = false, features = ["std"] }
-futures-util = { version = "0.3.7", default-features = false, features = [] }
+futures-core = { version = "0.3.17", default-features = false, features = ["std"] }
+futures-util = { version = "0.3.17", default-features = false, features = [] }
 log = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_urlencoded = "0.7"
 tls-openssl = { package = "openssl", version = "0.10.9", optional = true }
 tls-rustls = { package = "rustls", version = "0.20.0", optional = true }
-tokio = { version = "1.8.4", features = ["sync"] }
+tokio = { version = "1.18.4", features = ["sync"] }
--- a/actix-test/src/lib.rs
+++ b/actix-test/src/lib.rs
@ -321,6 +321,7 @@ where
            // all thread managed resources should be dropped at this point
        });

+        #[allow(clippy::let_underscore_future)]
        let _ = thread_stop_tx.send(());
    });

@ -567,6 +568,7 @@ impl Drop for TestServer {
        // without needing to await anything

        // signal server to stop
+        #[allow(clippy::let_underscore_future)]
        let _ = self.server.stop(true);

        // signal system to stop
--- a/actix-web-actors/Cargo.toml
+++ b/actix-web-actors/Cargo.toml
@ -21,9 +21,10 @@ actix-web = { version = "4", default-features = false }

 bytes = "1"
 bytestring = "1"
-futures-core = { version = "0.3.7", default-features = false }
+futures-core = { version = "0.3.17", default-features = false }
 pin-project-lite = "0.2"
-tokio = { version = "1.13.1", features = ["sync"] }
+tokio = { version = "1.18.4", features = ["sync"] }
+tokio-util = { version = "0.7", features = ["codec"] }

 [dev-dependencies]
 actix-rt = "2.2"
@ -34,4 +35,4 @@ actix-web = { version = "4", features = ["macros"] }
 mime = "0.3"

 env_logger = "0.9"
-futures-util = { version = "0.3.7", default-features = false }
+futures-util = { version = "0.3.17", default-features = false }
--- a/actix-web-actors/README.md
+++ b/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.57+-ab6000.svg)
+![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)
--- a/actix-web-actors/src/lib.rs
+++ b/actix-web-actors/src/lib.rs
@ -57,6 +57,7 @@

 #![deny(rust_2018_idioms, nonstandard_style)]
 #![warn(future_incompatible)]
+#![allow(clippy::uninlined_format_args)]

 mod context;
 pub mod ws;
--- a/actix-web-actors/src/ws.rs
+++ b/actix-web-actors/src/ws.rs
@ -74,7 +74,6 @@ use actix::{
    Actor, ActorContext, ActorState, Addr, AsyncContext, Handler, Message as ActixMessage,
    SpawnHandle,
 };
-use actix_codec::{Decoder as _, Encoder as _};
 use actix_http::ws::{hash_key, Codec};
 pub use actix_http::ws::{
    CloseCode, CloseReason, Frame, HandshakeError, Message, ProtocolError,
@ -92,6 +91,7 @@ use bytestring::ByteString;
 use futures_core::Stream;
 use pin_project_lite::pin_project;
 use tokio::sync::oneshot;
+use tokio_util::codec::{Decoder as _, Encoder as _};

 /// Builder for Websocket session response.
 ///
--- a/actix-web-actors/tests/test_ws.rs
+++ b/actix-web-actors/tests/test_ws.rs
@ -3,7 +3,7 @@ use actix_http::ws::Codec;
 use actix_web::{web, App, HttpRequest};
 use actix_web_actors::ws;
 use bytes::Bytes;
-use futures_util::{SinkExt, StreamExt};
+use futures_util::{SinkExt as _, StreamExt as _};

 struct Ws;

--- a/actix-web-codegen/CHANGES.md
+++ b/actix-web-codegen/CHANGES.md
@ -1,8 +1,11 @@
 # Changes

 ## 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.57 due to transitive `time` dependency.
+- Minimum supported Rust version (MSRV) is now 1.59 due to transitive `time` dependency.

 [#2718]: https://github.com/actix/actix-web/pull/2718

--- a/actix-web-codegen/Cargo.toml
+++ b/actix-web-codegen/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web-codegen"
-version = "4.0.1"
+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,7 +15,7 @@ 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", "extra-traits"] }
@ -24,9 +24,9 @@ syn = { version = "1", features = ["full", "extra-traits"] }
 actix-macros = "0.2.3"
 actix-rt = "2.2"
 actix-test = "0.1"
-actix-utils = "3.0.0"
-actix-web = "4.0.0"
+actix-utils = "3"
+actix-web = "4"

-futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
+futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 trybuild = "1"
 rustversion = "1"
--- a/actix-web-codegen/README.md
+++ b/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.1)](https://docs.rs/actix-web-codegen/4.0.1)
-![Version](https://img.shields.io/badge/rustc-1.57+-ab6000.svg)
+[![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.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.1/status.svg)](https://deps.rs/crate/actix-web-codegen/4.0.1)
+[![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)

--- a/actix-web-codegen/src/route.rs
+++ b/actix-web-codegen/src/route.rs
@ -155,7 +155,7 @@ impl Args {
                            if !methods.insert(method) {
                                return Err(syn::Error::new_spanned(
                                    &nv.lit,
-                                    &format!(
+                                    format!(
                                        "HTTP method defined more than once: `{}`",
                                        lit.value()
                                    ),
--- a/actix-web-codegen/tests/trybuild.rs
+++ b/actix-web-codegen/tests/trybuild.rs
@ -1,4 +1,4 @@
-#[rustversion::stable(1.57)] // MSRV
+#[rustversion::stable(1.59)] // MSRV
 #[test]
 fn compile_macros() {
    let t = trybuild::TestCases::new();
--- a/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr
@ -4,10 +4,16 @@ error: HTTP method defined more than once: `GET`
 3 | #[route("/", method="GET", method="GET")]
  |                                   ^^^^^

-error[E0277]: the trait bound `fn() -> impl std::future::Future {index}: HttpServiceFactory` is not satisfied
-  --> 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}`
-   |                                               |
-   |                                               required by a bound introduced by this call
+error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String> {index}: HttpServiceFactory` is not satisfied
+   --> 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<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`
--- a/actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr
@ -6,10 +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
-  --> 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}`
-   |                                               |
-   |                                               required by a bound introduced by this call
+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<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`
--- a/actix-web-codegen/tests/trybuild/route-unexpected-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/route-unexpected-method-fail.stderr
@ -4,10 +4,16 @@ error: Unexpected HTTP method: `UNEXPECTED`
 3 | #[route("/", method="UNEXPECTED")]
  |                     ^^^^^^^^^^^^

-error[E0277]: the trait bound `fn() -> impl std::future::Future {index}: HttpServiceFactory` is not satisfied
-  --> 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}`
-   |                                               |
-   |                                               required by a bound introduced by this call
+error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String> {index}: HttpServiceFactory` is not satisfied
+   --> 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<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`
--- a/actix-web-codegen/tests/trybuild/routes-missing-args-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/routes-missing-args-fail.stderr
@ -12,10 +12,16 @@ error: Invalid input for macro
 4 | #[get]
  | ^^^^^^

-error[E0277]: the trait bound `fn() -> impl std::future::Future {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 {index}`
-   |                                               |
-   |                                               required by a bound introduced by this call
+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`
--- a/actix-web-codegen/tests/trybuild/routes-missing-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/routes-missing-method-fail.stderr
@ -6,10 +6,16 @@ error: The #[routes] macro requires at least one `#[<method>(..)]` attribute.
  |
  = 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 {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 {index}`
-   |                                               |
-   |                                               required by a bound introduced by this call
+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`
--- a/actix-web/CHANGES.md
+++ b/actix-web/CHANGES.md
@ -1,13 +1,44 @@
 # Changelog

 ## Unreleased - 2022-xx-xx
+
+
+## 4.3.0 - 2023-01-21
+### 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]
+- Add `Logger::custom_response_replace()`. [#2631]
+- Add rudimentary redirection service at `web::redirect()` / `web::Redirect`. [#1961]
+- Add `guard::Acceptable` for matching against `Accept` header MIME types. [#2265]
+- Add fallible versions of `test` helpers: `try_call_service()`, `try_call_and_read_body_json()`, `try_read_body()`, and `try_read_body_json()`. [#2961]
+
+### Fixed
+- Add `Allow` header to `Resource`'s default responses when no routes are matched. [#2949]
+
+[#1961]: https://github.com/actix/actix-web/pull/1961
+[#2265]: https://github.com/actix/actix-web/pull/2265
+[#2631]: https://github.com/actix/actix-web/pull/2631
+[#2784]: https://github.com/actix/actix-web/pull/2784
+[#2867]: https://github.com/actix/actix-web/pull/2867
+[#2949]: https://github.com/actix/actix-web/pull/2949
+[#2961]: https://github.com/actix/actix-web/pull/2961
+
+
+## 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.57 due to transitive `time` dependency.
+- 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
--- a/actix-web/Cargo.toml
+++ b/actix-web/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "4.1.0"
+version = "4.3.0"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
    "Rob Ede <robjtede@icloud.com>",
@ -38,10 +38,7 @@ compress-gzip = ["actix-http/compress-gzip", "__compress"]
 compress-zstd = ["actix-http/compress-zstd", "__compress"]

 # Routing and runtime proc macros
-macros = [
-    "actix-macros",
-    "actix-web-codegen",
-]
+macros = ["actix-macros", "actix-web-codegen"]

 # Cookies support
 cookies = ["cookie"]
@ -71,19 +68,19 @@ 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.3", 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 }
+futures-core = { version = "0.3.17", default-features = false }
+futures-util = { version = "0.3.17", default-features = false }
 http = "0.2.8"
 itoa = "1"
 language-tags = "0.3"
@ -107,10 +104,10 @@ awc = { version = "3", features = ["openssl"] }

 brotli = "3.3.3"
 const-str = "0.4"
-criterion = { version = "0.3", features = ["html_reports"] }
+criterion = { version = "0.4", features = ["html_reports"] }
 env_logger = "0.9"
 flate2 = "1.0.13"
-futures-util = { version = "0.3.7", default-features = false, features = ["std"] }
+futures-util = { version = "0.3.17", default-features = false, features = ["std"] }
 rand = "0.8"
 rcgen = "0.9"
 rustls-pemfile = "1"
@ -118,8 +115,8 @@ 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.11"
+tokio = { version = "1.18.4", features = ["rt-multi-thread", "macros"] }
+zstd = "0.12"

 [[test]]
 name = "test_server"
--- a/actix-web/README.md
+++ b/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.1.0)](https://docs.rs/actix-web/4.1.0)
-![MSRV](https://img.shields.io/badge/rustc-1.57+-ab6000.svg)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.3.0)](https://docs.rs/actix-web/4.3.0)
+![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.1.0/status.svg)](https://deps.rs/crate/actix-web/4.1.0)
+[![Dependency Status](https://deps.rs/crate/actix-web/4.3.0/status.svg)](https://deps.rs/crate/actix-web/4.3.0)
 <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.57+
+- Runs on stable Rust 1.59+

 ## Documentation

--- a/actix-web/benches/server.rs
+++ b/actix-web/benches/server.rs
@ -1,3 +1,5 @@
+#![allow(clippy::uninlined_format_args)]
+
 use actix_web::{web, App, HttpResponse};
 use awc::Client;
 use criterion::{criterion_group, criterion_main, Criterion};
--- a/actix-web/examples/basic.rs
+++ b/actix-web/examples/basic.rs
@ -1,3 +1,5 @@
+#![allow(clippy::uninlined_format_args)]
+
 use actix_web::{get, middleware, web, App, HttpRequest, HttpResponse, HttpServer};

 #[get("/resource1/{name}/index.html")]
--- a/actix-web/examples/macroless.rs
+++ b/actix-web/examples/macroless.rs
@ -1,3 +1,5 @@
+#![allow(clippy::uninlined_format_args)]
+
 use actix_web::{middleware, rt, web, App, HttpRequest, HttpServer};

 async fn index(req: HttpRequest) -> &'static str {
--- a/actix-web/examples/on-connect.rs
+++ b/actix-web/examples/on-connect.rs
@ -4,6 +4,8 @@
 //! For an example of extracting a client TLS certificate, see:
 //! <https://github.com/actix/examples/tree/master/https-tls/rustls-client-cert>

+#![allow(clippy::uninlined_format_args)]
+
 use std::{any::Any, io, net::SocketAddr};

 use actix_web::{
--- a/actix-web/examples/uds.rs
+++ b/actix-web/examples/uds.rs
@ -1,3 +1,5 @@
+#![allow(clippy::uninlined_format_args)]
+
 use actix_web::{get, web, HttpRequest};
 #[cfg(unix)]
 use actix_web::{middleware, App, Error, HttpResponse, HttpServer};
--- a/actix-web/src/app.rs
+++ b/actix-web/src/app.rs
@ -5,7 +5,7 @@ use actix_service::{
    apply, apply_fn_factory, boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt,
    Transform,
 };
-use futures_util::future::FutureExt as _;
+use futures_util::FutureExt as _;

 use crate::{
    app_service::{AppEntry, AppInit, AppRoutingFactory},
@ -682,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())
                    }),
                ),
        )
@ -712,6 +712,7 @@ mod tests {
                .route("/", web::to(|| async { "hello" }))
        }

+        #[allow(clippy::let_underscore_future)]
        let _ = init_service(my_app());
    }
 }
--- a/actix-web/src/app_service.rs
+++ b/actix-web/src/app_service.rs
@ -173,7 +173,7 @@ impl AppInitServiceState {

    #[inline]
    pub(crate) fn rmap(&self) -> &ResourceMap {
-        &*self.rmap
+        &self.rmap
    }

    #[inline]
--- a/actix-web/src/config.rs
+++ b/actix-web/src/config.rs
@ -344,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())
                    }),
                ),
        )
--- a/actix-web/src/guard/acceptable.rs
+++ b/actix-web/src/guard/acceptable.rs
@ -0,0 +1,99 @@
+use super::{Guard, GuardContext};
+use crate::http::header::Accept;
+
+/// A guard that verifies that an `Accept` header is present and it contains a compatible MIME type.
+///
+/// An exception is that matching `*/*` must be explicitly enabled because most browsers send this
+/// as part of their `Accept` header for almost every request.
+///
+/// # Examples
+/// ```
+/// use actix_web::{guard::Acceptable, web, HttpResponse};
+///
+/// web::resource("/images")
+///     .guard(Acceptable::new(mime::IMAGE_STAR))
+///     .default_service(web::to(|| async {
+///         HttpResponse::Ok().body("only called when images responses are acceptable")
+///     }));
+/// ```
+#[derive(Debug, Clone)]
+pub struct Acceptable {
+    mime: mime::Mime,
+
+    /// Wether to match `*/*` mime type.
+    ///
+    /// Defaults to false because it's not very useful otherwise.
+    match_star_star: bool,
+}
+
+impl Acceptable {
+    /// Constructs new `Acceptable` guard with the given `mime` type/pattern.
+    pub fn new(mime: mime::Mime) -> Self {
+        Self {
+            mime,
+            match_star_star: false,
+        }
+    }
+
+    /// Allows `*/*` in the `Accept` header to pass the guard check.
+    pub fn match_star_star(mut self) -> Self {
+        self.match_star_star = true;
+        self
+    }
+}
+
+impl Guard for Acceptable {
+    fn check(&self, ctx: &GuardContext<'_>) -> bool {
+        let accept = match ctx.header::<Accept>() {
+            Some(hdr) => hdr,
+            None => return false,
+        };
+
+        let target_type = self.mime.type_();
+        let target_subtype = self.mime.subtype();
+
+        for mime in accept.0.into_iter().map(|q| q.item) {
+            return match (mime.type_(), mime.subtype()) {
+                (typ, subtype) if typ == target_type && subtype == target_subtype => true,
+                (typ, mime::STAR) if typ == target_type => true,
+                (mime::STAR, mime::STAR) if self.match_star_star => true,
+                _ => continue,
+            };
+        }
+
+        false
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{http::header, test::TestRequest};
+
+    #[test]
+    fn test_acceptable() {
+        let req = TestRequest::default().to_srv_request();
+        assert!(!Acceptable::new(mime::APPLICATION_JSON).check(&req.guard_ctx()));
+
+        let req = TestRequest::default()
+            .insert_header((header::ACCEPT, "application/json"))
+            .to_srv_request();
+        assert!(Acceptable::new(mime::APPLICATION_JSON).check(&req.guard_ctx()));
+
+        let req = TestRequest::default()
+            .insert_header((header::ACCEPT, "text/html, application/json"))
+            .to_srv_request();
+        assert!(Acceptable::new(mime::APPLICATION_JSON).check(&req.guard_ctx()));
+    }
+
+    #[test]
+    fn test_acceptable_star() {
+        let req = TestRequest::default()
+            .insert_header((header::ACCEPT, "text/html, */*;q=0.8"))
+            .to_srv_request();
+
+        assert!(Acceptable::new(mime::APPLICATION_JSON)
+            .match_star_star()
+            .check(&req.guard_ctx()));
+    }
+}
--- a/actix-web/src/guard/mod.rs
+++ b/actix-web/src/guard/mod.rs
@ -56,6 +56,9 @@ use actix_http::{header, uri::Uri, Extensions, Method as HttpMethod, RequestHead

 use crate::{http::header::Header, service::ServiceRequest, HttpMessage as _};

+mod acceptable;
+pub use self::acceptable::Acceptable;
+
 /// Provides access to request parts that are useful during routing.
 #[derive(Debug)]
 pub struct GuardContext<'a> {
@ -193,6 +196,7 @@ impl AnyGuard {
 }

 impl Guard for AnyGuard {
+    #[inline]
    fn check(&self, ctx: &GuardContext<'_>) -> bool {
        for guard in &self.guards {
            if guard.check(ctx) {
@ -244,12 +248,14 @@ impl AllGuard {
 }

 impl Guard for AllGuard {
+    #[inline]
    fn check(&self, ctx: &GuardContext<'_>) -> bool {
        for guard in &self.guards {
            if !guard.check(ctx) {
                return false;
            }
        }
+
        true
    }
 }
@ -268,6 +274,7 @@ impl Guard for AllGuard {
 pub struct Not<G>(pub G);

 impl<G: Guard> Guard for Not<G> {
+    #[inline]
    fn check(&self, ctx: &GuardContext<'_>) -> bool {
        !self.0.check(ctx)
    }
@ -279,11 +286,25 @@ pub fn Method(method: HttpMethod) -> impl Guard {
    MethodGuard(method)
 }

+#[derive(Debug, Clone)]
+pub(crate) struct RegisteredMethods(pub(crate) Vec<HttpMethod>);
+
 /// HTTP method guard.
-struct MethodGuard(HttpMethod);
+#[derive(Debug)]
+pub(crate) struct MethodGuard(HttpMethod);

 impl Guard for MethodGuard {
    fn check(&self, ctx: &GuardContext<'_>) -> bool {
+        let registered = ctx.req_data_mut().remove::<RegisteredMethods>();
+
+        if let Some(mut methods) = registered {
+            methods.0.push(self.0.clone());
+            ctx.req_data_mut().insert(methods);
+        } else {
+            ctx.req_data_mut()
+                .insert(RegisteredMethods(vec![self.0.clone()]));
+        }
+
        ctx.head().method == self.0
    }
 }
--- a/actix-web/src/http/header/accept.rs
+++ b/actix-web/src/http/header/accept.rs
@ -6,8 +6,7 @@ use super::{common_header, QualityItem};
 use crate::http::header;

 common_header! {
-    /// `Accept` header, defined
-    /// in [RFC 7231 §5.3.2](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2)
+    /// `Accept` header, defined in [RFC 7231 §5.3.2].
    ///
    /// The `Accept` header field can be used by user agents to specify
    /// response media types that are acceptable. Accept header fields can
@ -71,6 +70,8 @@ common_header! {
    ///     ])
    /// );
    /// ```
+    ///
+    /// [RFC 7231 §5.3.2]: https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
    (Accept, header::ACCEPT) => (QualityItem<Mime>)*

    test_parse_and_format {
@ -101,13 +102,12 @@ common_header! {
            vec![b"text/plain; charset=utf-8"],
            Some(Accept(vec![
                QualityItem::max(mime::TEXT_PLAIN_UTF_8),
-                ])));
+            ])));
        crate::http::header::common_header_test!(
            test4,
            vec![b"text/plain; charset=utf-8; q=0.5"],
            Some(Accept(vec![
-                QualityItem::new(mime::TEXT_PLAIN_UTF_8,
-                    q(0.5)),
+                QualityItem::new(mime::TEXT_PLAIN_UTF_8, q(0.5)),
            ])));

        #[test]
--- a/actix-web/src/http/header/cache_control.rs
+++ b/actix-web/src/http/header/cache_control.rs
@ -176,7 +176,7 @@ impl str::FromStr for CacheDirective {

            _ => match s.find('=') {
                Some(idx) if idx + 1 < s.len() => {
-                    match (&s[..idx], (&s[idx + 1..]).trim_matches('"')) {
+                    match (&s[..idx], s[idx + 1..].trim_matches('"')) {
                        ("max-age", secs) => secs.parse().map(MaxAge).map_err(Some),
                        ("max-stale", secs) => secs.parse().map(MaxStale).map_err(Some),
                        ("min-fresh", secs) => secs.parse().map(MinFresh).map_err(Some),
--- a/actix-web/src/http/header/content_disposition.rs
+++ b/actix-web/src/http/header/content_disposition.rs
@ -79,7 +79,7 @@ impl<'a> From<&'a str> for DispositionType {
 /// assert!(param.is_filename());
 /// assert_eq!(param.as_filename().unwrap(), "sample.txt");
 /// ```
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[allow(clippy::large_enum_variant)]
 pub enum DispositionParam {
    /// For [`DispositionType::FormData`] (i.e. *multipart/form-data*), the name of an field from
@ -302,7 +302,7 @@ impl DispositionParam {
 /// change to match local file system conventions if applicable, and do not use directory path
 /// information that may be present.
 /// See [RFC 2183 §2.3](https://datatracker.ietf.org/doc/html/rfc2183#section-2.3).
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ContentDisposition {
    /// The disposition type
    pub disposition: DispositionType,
@ -312,16 +312,36 @@ pub struct ContentDisposition {
 }

 impl ContentDisposition {
+    /// Constructs a Content-Disposition header suitable for downloads.
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_web::http::header::{ContentDisposition, TryIntoHeaderValue as _};
+    ///
+    /// let cd = ContentDisposition::attachment("files.zip");
+    ///
+    /// let cd_val = cd.try_into_value().unwrap();
+    /// assert_eq!(cd_val, "attachment; filename=\"files.zip\"");
+    /// ```
+    pub fn attachment(filename: impl Into<String>) -> Self {
+        Self {
+            disposition: DispositionType::Attachment,
+            parameters: vec![DispositionParam::Filename(filename.into())],
+        }
+    }
+
    /// Parse a raw Content-Disposition header value.
    pub fn from_raw(hv: &header::HeaderValue) -> Result<Self, crate::error::ParseError> {
        // `header::from_one_raw_str` invokes `hv.to_str` which assumes `hv` contains only visible
        //  ASCII characters. So `hv.as_bytes` is necessary here.
        let hv = String::from_utf8(hv.as_bytes().to_vec())
            .map_err(|_| crate::error::ParseError::Header)?;
+
        let (disp_type, mut left) = split_once_and_trim(hv.as_str().trim(), ';');
        if disp_type.is_empty() {
            return Err(crate::error::ParseError::Header);
        }
+
        let mut cd = ContentDisposition {
            disposition: disp_type.into(),
            parameters: Vec::new(),
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Rob Ede	df6fde883c	prepare actix-web release 4.3.0	2023-01-21 18:57:42 +00:00
Rob Ede	8d4cb8c69a	prepare awc release 3.1.0	2023-01-21 18:54:58 +00:00
Rob Ede	dd9ac4d9b8	prepare actix-http release 3.3.0	2023-01-21 18:52:57 +00:00
Rob Ede	72c80f9107	update tokio-uring support to 0.4	2023-01-21 18:46:44 +00:00
citreae535	b00fe72cf6	Update base64 to 0.21 (#2966 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2023-01-21 01:36:08 +00:00
cumtyc	2f0b8a264a	fix non-empty body of http2 HEAD response (#2920 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2023-01-21 00:51:49 +00:00
Rob Ede	b9f0faafde	add cache-status and cdn-cache-control header names (#2968 ) * add cache-status and cdn-cache-control header names * fix changelog * update docs with rfc numbers	2023-01-21 00:02:54 +00:00
Zach	6627109984	Add fallible versions of test_utils helpers to actix-test (#2961 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2023-01-11 11:43:51 +00:00
Rob Ede	b9f54c8796	use secure tokio version range see RUSTSEC-2023-0001 fixes #2962	2023-01-10 08:58:38 +00:00
Nikolai Vazquez	cfd40b4f15	Implement `MessageBody` for `Cow<'static, {[u8], str}>` (#2959 )	2023-01-06 21:56:16 +00:00
Rob Ede	08c2cdf641	http service finalizer for automatic h2c detection (#2957 ) * http service finalizer for automatic h2c detection * update changelog * add h2c auto test	2023-01-03 14:43:02 +00:00
Rob Ede	fbd0e5dd0a	add headermap::retain (#2955 ) * add headermap::retain * update changelog and docs * fix retain doc test	2023-01-02 13:38:07 +00:00
Rob Ede	7b936bc443	add some useful header name constants (#2956 )	2023-01-02 13:33:31 +00:00
Rob Ede	d2364c80c4	improve error handling on new new example	2023-01-02 00:16:59 +00:00
Rob Ede	77459ec415	add h2c example	2023-01-02 00:14:25 +00:00
Rob Ede	6f0a6bd1bb	address clippy lints For intrepid commit message readers: The choice to add allows for the inlined format args lint instead of actually inlining them is not very clear because our actual real world MSRV is not clear. We currently claim 1.60 is our MSRV but this is mainly due to dependencies. I'm fairly sure that we could support < 1.58 if those deps are outdated in a users lockfile. We'll remove these allows again at some point soon.	2023-01-01 20:56:34 +00:00
Rob Ede	06c3513bc0	add Allow header to resource's default 405 handler (#2949 )	2022-12-21 20:28:45 +00:00
Rob Ede	29bd6a1dd5	fix version requirement for futures_util	2022-12-18 01:34:48 +00:00
Rob Ede	17f7cd2aae	bump zstd to 0.12	2022-12-18 01:31:06 +00:00
Rob Ede	ede645ee4e	bump criterion to 0.4	2022-12-18 01:11:04 +00:00
Rob Ede	6d48593a60	fix doc tests	2022-11-25 23:28:31 +00:00
Rob Ede	3c69d078b2	add redirect service (#1961 )	2022-11-25 21:44:52 +00:00
Rob Ede	e7c34f2e45	tweak form docs	2022-11-25 21:38:57 +00:00
Rob Ede	d708a4de6d	add acceptable guard (#2265 )	2022-11-25 21:04:24 +00:00
Rob Ede	d97bd7ec17	fix msrv CI	2022-11-25 17:37:23 +00:00
Rob Ede	fcd06c9896	workaround zstd msrv issue	2022-11-25 17:28:06 +00:00
Rob Ede	1065043528	ci: use dtolnay's rust-toolchain action	2022-11-25 17:00:59 +00:00
Alex	45b77c6819	GitHub Workflows security hardening (#2923 )	2022-11-04 00:42:22 +00:00
Rob Ede	a2e2c30d59	use tokio-util deps directly where possible	2022-10-30 19:47:49 +00:00
fakeshadow	83cd061c86	remove fakeshadow from author lists (#2921 )	2022-10-25 16:37:04 +01:00
Alex	068909f1b3	Replace deprecated twoway with memchr (#2909 )	2022-10-14 11:52:13 +00:00
Rob Ede	f8cb71e789	remove incomplete doc comment	2022-10-14 13:20:38 +02:00
kkocdko	73b94e902d	fix xhtml pages' `content-disposition` (#2903 ) Co-authored-by: Yuki Okushi <jtitor@2k36.org>	2022-10-09 12:44:10 +01:00
Benny Nazimov	ad7e67f940	add `middleware::logger::custom_response_replace` (#2631 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2022-09-26 18:44:51 +00:00
Rob Ede	1519ae7772	clarify tokio::main docs	2022-09-26 12:29:57 +01:00
Rob Ede	cc7145d41d	rust 1.64 clippy run (#2891 )	2022-09-25 20:54:17 +01:00
Rob Ede	172c4c7a0a	use noop hasher in extensions (#2890 )	2022-09-25 15:32:26 +01:00
Jacob Halsey	fd63305859	Fix actix-multipart field content_type() to return an Option (#2885 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2022-09-23 17:06:40 +00:00
david-monroe	ef64d6a27c	update derive_more dependency to 0.99.8 (#2888 )	2022-09-23 12:39:18 +00:00
e-rhodes	4d3689db5e	Remove unnecesary clones in extractor configs (#2884 ) Co-authored-by: erhodes <erik@space-nav.com> Co-authored-by: Rob Ede <robjtede@icloud.com>	2022-09-20 23:17:58 +00:00
Rob Ede	894effb856	prepare actix-router release 0.5.1	2022-09-19 18:52:16 +01:00
Torin Cooper-Bennun	07a7290432	Fix typo in error string for i32 parse in router deserialization (#2876 ) * fix typo in error string for i32 parse * update actix-router changelog for #2876 * Update CHANGES.md Co-authored-by: Rob Ede <robjtede@icloud.com>	2022-09-19 18:44:52 +01:00
e-rhodes	bd5c0af0a6	Add ability to set default error handlers to the `ErrorHandler` middleware (#2784 ) Co-authored-by: erhodes <erik@space-nav.com> Co-authored-by: Rob Ede <robjtede@icloud.com>	2022-09-15 13:06:34 +00:00
Rob Ede	c73fba16ce	implement MessageBody for mut B (#2868 )	2022-09-14 11:23:22 +01:00
Rob Ede	909461087c	add `ContentDisposition::attachment` constructor (#2867 )	2022-09-13 01:19:25 +01:00
Rob Ede	40f7ab38d2	prepare actix-web release 4.2.1	2022-09-12 10:43:03 +01:00
Rob Ede	a9e44bcf07	fix -http version to 3.2.2 (#2871 ) fixes #2869	2022-09-12 10:42:22 +01:00
Rob Ede	7767cf3071	prepare actix-web release 4.2.0	2022-09-11 16:44:46 +01:00
Rob Ede	b59a96d9d7	prepare actix-web-codegen release 4.1.0	2022-09-11 16:42:28 +01:00
Rob Ede	037740bf62	prepare actix-http release 3.2.2	2022-09-11 16:41:29 +01:00
Rob Ede	386258c285	clarify worker_max_blocking_threads default	2022-09-06 10:13:10 +01:00
Rob Ede	99bf774e94	update gh-pages deploy action	2022-09-03 22:15:59 +01:00
Rob Ede	35b0fd1a85	specify branch in doc job	2022-09-03 22:05:28 +01:00
Rob Ede	0b5b4dcbf3	reduce size of docs branch	2022-09-03 21:56:37 +01:00
Juan Aguilar	c993055fc8	replace askama_escape in favor of v_htmlescape (#2824 )	2022-08-30 09:34:46 +01:00
Rob Ede	679f61cf37	bump msrv to 1.59	2022-08-27 13:14:16 +01:00
Rob Ede	056de320f0	fix scope doc example fixes #2843	2022-08-25 03:17:48 +01:00
Rob Ede	f220719fae	prepare awc release 3.0.1	2022-08-25 03:13:31 +01:00
liushuyu	c9f91796df	awc: correctly handle redirections that begins with `//` (#2840 )	2022-08-25 03:12:58 +01:00
Rob Ede	ea764b1d57	add feature annotations to docs	2022-07-31 23:40:09 +01:00
Rob Ede	19aa14a9d6	re-order HttpServer methods for better docs	2022-07-31 22:10:51 +01:00
Rob Ede	10746fb2fb	improve HttpServer docs	2022-07-31 21:58:15 +01:00
Rob Ede	4bbe60b609	document h2 ping-pong	2022-07-24 16:42:35 +01:00
Rob Ede	8ff489aa90	apply fix from #2369	2022-07-24 16:35:00 +01:00