Merge branch 'master' into custom_headers_in_redirects

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
           - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin }
           - { name: Windows, os: windows-latest, triple: x86_64-pc-windows-msvc }
         version:
-          - 1.46.0 # MSRV
+          - 1.51.0 # MSRV
           - stable
           - nightly
 

CHANGES.md

@@ -4,6 +4,9 @@
 ### Added
 * Re-export actix-service `ServiceFactory` in `dev` module. [#2325]
 
+### Changes
+* Minimum supported Rust version (MSRV) is now 1.51.
+
 [#2325]: https://github.com/actix/actix-web/pull/2325
 
 

Cargo.toml

@@ -24,6 +24,7 @@ name = "actix_web"
 path = "src/lib.rs"
 
 [workspace]
+resolver = "2"
 members = [
     ".",
     "awc",
@@ -34,6 +35,7 @@ members = [
     "actix-web-codegen",
     "actix-http-test",
     "actix-test",
+    "actix-router",
 ]
 # enable when MSRV is 1.51+
 # resolver = "2"
@@ -67,7 +69,7 @@ __compress = []
 [dependencies]
 actix-codec = "0.4.0"
 actix-macros = "0.2.1"
-actix-router = "0.2.7"
+actix-router = "0.5.0-beta.1"
 actix-rt = "2.2"
 actix-server = "2.0.0-beta.3"
 actix-service = "2.0.0"
@@ -75,7 +77,7 @@ actix-utils = "3.0.0"
 actix-tls = { version = "3.0.0-beta.5", default-features = false, optional = true }
 
 actix-web-codegen = "0.5.0-beta.2"
-actix-http = "3.0.0-beta.8"
+actix-http = "3.0.0-beta.9"
 
 ahash = "0.7"
 bytes = "1"
@@ -126,6 +128,7 @@ actix-files = { path = "actix-files" }
 actix-http = { path = "actix-http" }
 actix-http-test = { path = "actix-http-test" }
 actix-multipart = { path = "actix-multipart" }
+actix-router = { path = "actix-router" }
 actix-test = { path = "actix-test" }
 actix-web = { path = "." }
 actix-web-actors = { path = "actix-web-actors" }

MIGRATION.md

@@ -3,7 +3,8 @@
 * The default `NormalizePath` behavior now strips trailing slashes by default. This was
   previously documented to be the case in v3 but the behavior now matches. The effect is that
   routes defined with trailing slashes will become inaccessible when
-  using `NormalizePath::default()`.
+  using `NormalizePath::default()`. As such, calling `NormalizePath::default()` will log a warning.
+  It is advised that the `new` method be used instead.
   
   Before: `#[get("/test/")]`  
   After:  `#[get("/test")]`  

README.md

@@ -7,7 +7,7 @@
 
 [![crates.io](https://img.shields.io/crates/v/actix-web?label=latest)](https://crates.io/crates/actix-web)
 [![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.8)](https://docs.rs/actix-web/4.0.0-beta.8)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Version](https://img.shields.io/badge/rustc-1.51+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.51.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
 [![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.8/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.8)
 <br />
@@ -32,7 +32,7 @@
 * SSL support using OpenSSL or Rustls
 * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
 * Includes an async [HTTP client](https://docs.rs/awc/)
-* Runs on stable Rust 1.46+
+* Runs on stable Rust 1.51+
 
 ## Documentation
 

actix-files/CHANGES.md

@@ -1,6 +1,7 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+* Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 0.6.0-beta.6 - 2021-06-26

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.0-beta.6)](https://docs.rs/actix-files/0.6.0-beta.6)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Version](https://img.shields.io/badge/rustc-1.51+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.51.html)
 ![License](https://img.shields.io/crates/l/actix-files.svg)
 <br />
 [![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.6/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.6)
@@ -15,4 +15,4 @@
 
 - [API Documentation](https://docs.rs/actix-files/)
 - [Example Project](https://github.com/actix/examples/tree/master/basics/static_index)
-- Minimum supported Rust version: 1.46 or later
+- Minimum supported Rust version: 1.51 or later

actix-files/src/error.rs

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

actix-files/src/files.rs

@@ -106,7 +106,7 @@ impl Files {
         };
 
         Files {
-            path: mount_path.to_owned(),
+            path: mount_path.trim_end_matches('/').to_owned(),
             directory: dir,
             index: None,
             show_index: false,

actix-http-test/CHANGES.md

@@ -1,6 +1,7 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+* Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 3.0.0-beta.4 - 2021-04-02

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-beta.4)](https://docs.rs/actix-http-test/3.0.0-beta.4)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Version](https://img.shields.io/badge/rustc-1.51+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.51.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http-test)
 <br>
 [![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0-beta.4)
@@ -14,4 +14,4 @@
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-http-test)
-- Minimum Supported Rust Version (MSRV): 1.46.0
+- Minimum Supported Rust Version (MSRV): 1.51.0

actix-http/CHANGES.md

@@ -1,6 +1,20 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+### Changes
+* Minimum supported Rust version (MSRV) is now 1.51.
+
+### Fixed
+* Remove slice creation pointing to potential uninitialized data on h1 encoder. [#2364]
+* Remove `Into<Error>` bound on `Encoder` body types. [#2375]
+
+[#2364]: https://github.com/actix/actix-web/pull/2364
+[#2375]: https://github.com/actix/actix-web/pull/2375
+
+
+## 3.0.0-beta.8 - 2021-08-09
+### Fixed
+* Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
 
 
 ## 3.0.0-beta.8 - 2021-06-26
@@ -210,6 +224,11 @@
 [#1878]: https://github.com/actix/actix-web/pull/1878
 
 
+## 2.2.1 - 2021-08-09
+### Fixed
+* Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
+
+
 ## 2.2.0 - 2020-11-25
 ### Added
 * HttpResponse builders for 1xx status codes. [#1768]

actix-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "3.0.0-beta.8"
+version = "3.0.0-beta.9"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "HTTP primitives for the Actix ecosystem"
 keywords = ["actix", "http", "framework", "async", "futures"]
@@ -59,7 +59,7 @@ futures-core = { version = "0.3.7", default-features = false, features = ["alloc
 futures-util = { version = "0.3.7", default-features = false, features = ["alloc", "sink"] }
 h2 = "0.3.1"
 http = "0.2.2"
-httparse = "1.3"
+httparse = "1.5.1"
 itoa = "0.4"
 language-tags = "0.3"
 local-channel = "0.1"

actix-http/README.md

@@ -3,18 +3,18 @@
 > HTTP primitives for the Actix ecosystem.
 
 [![crates.io](https://img.shields.io/crates/v/actix-http?label=latest)](https://crates.io/crates/actix-http)
-[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.8)](https://docs.rs/actix-http/3.0.0-beta.8)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.9)](https://docs.rs/actix-http/3.0.0-beta.9)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Version](https://img.shields.io/badge/rustc-1.51+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.51.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.8/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.8)
+[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.9/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.9)
 [![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)
 
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-http)
-- Minimum Supported Rust Version (MSRV): 1.46.0
+- Minimum Supported Rust Version (MSRV): 1.51.0
 
 ## Example
 

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

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

actix-http/src/body/body.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use bytes::{Bytes, BytesMut};
-use futures_core::{ready, Stream};
+use futures_core::Stream;
 
 use crate::error::Error;
 
@@ -74,14 +74,10 @@ impl MessageBody for AnyBody {
                 }
             }
 
-            // TODO: MSRV 1.51: poll_map_err
+            AnyBody::Message(body) => body
-            AnyBody::Message(body) => match ready!(body.as_pin_mut().poll_next(cx)) {
+                .as_pin_mut()
-                Some(Err(err)) => {
+                .poll_next(cx)
-                    Poll::Ready(Some(Err(Error::new_body().with_cause(err))))
+                .map_err(|err| Error::new_body().with_cause(err)),
-                }
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
         }
     }
 }
@@ -223,11 +219,9 @@ impl MessageBody for BoxAnyBody {
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        // TODO: MSRV 1.51: poll_map_err
+        self.0
-        match ready!(self.0.as_mut().poll_next(cx)) {
+            .as_mut()
-            Some(Err(err)) => Poll::Ready(Some(Err(Error::new_body().with_cause(err)))),
+            .poll_next(cx)
-            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+            .map_err(|err| Error::new_body().with_cause(err))
-            None => Poll::Ready(None),
-        }
     }
 }

actix-http/src/body/message_body.rs

@@ -11,8 +11,6 @@ use bytes::{Bytes, BytesMut};
 use futures_core::ready;
 use pin_project_lite::pin_project;
 
-use crate::error::Error;
-
 use super::BodySize;
 
 /// An interface for response bodies.
@@ -47,7 +45,6 @@ impl MessageBody for () {
 impl<B> MessageBody for Box<B>
 where
     B: MessageBody + Unpin,
-    B::Error: Into<Error>,
 {
     type Error = B::Error;
 
@@ -66,7 +63,6 @@ where
 impl<B> MessageBody for Pin<Box<B>>
 where
     B: MessageBody,
-    B::Error: Into<Error>,
 {
     type Error = B::Error;
 

actix-http/src/body/mod.rs

@@ -80,7 +80,7 @@ mod tests {
     impl Body {
         pub(crate) fn get_ref(&self) -> &[u8] {
             match *self {
-                Body::Bytes(ref bin) => &bin,
+                Body::Bytes(ref bin) => bin,
                 _ => panic!(),
             }
         }

actix-http/src/body/response_body.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use bytes::Bytes;
-use futures_core::{ready, Stream};
+use futures_core::Stream;
 use pin_project::pin_project;
 
 use crate::error::Error;
@@ -77,12 +77,7 @@ where
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         match self.project() {
-            // TODO: MSRV 1.51: poll_map_err
+            ResponseBodyProj::Body(body) => body.poll_next(cx).map_err(Into::into),
-            ResponseBodyProj::Body(body) => match ready!(body.poll_next(cx)) {
-                Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
             ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
         }
     }

actix-http/src/encoding/encoder.rs

@@ -29,7 +29,7 @@ use crate::{
         header::{ContentEncoding, CONTENT_ENCODING},
         HeaderValue, StatusCode,
     },
-    Error, ResponseHead,
+    ResponseHead,
 };
 
 use super::Writer;
@@ -107,7 +107,6 @@ enum EncoderBody<B> {
 impl<B> MessageBody for EncoderBody<B>
 where
     B: MessageBody,
-    B::Error: Into<Error>,
 {
     type Error = EncoderError<B::Error>;
 
@@ -131,18 +130,9 @@ where
                     Poll::Ready(Some(Ok(std::mem::take(b))))
                 }
             }
-            // TODO: MSRV 1.51: poll_map_err
+            EncoderBodyProj::Stream(b) => b.poll_next(cx).map_err(EncoderError::Body),
-            EncoderBodyProj::Stream(b) => match ready!(b.poll_next(cx)) {
-                Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Body(err)))),
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
             EncoderBodyProj::BoxedStream(ref mut b) => {
-                match ready!(b.as_pin_mut().poll_next(cx)) {
+                b.as_pin_mut().poll_next(cx).map_err(EncoderError::Boxed)
-                    Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Boxed(err)))),
-                    Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                    None => Poll::Ready(None),
-                }
             }
         }
     }
@@ -151,7 +141,6 @@ where
 impl<B> MessageBody for Encoder<B>
 where
     B: MessageBody,
-    B::Error: Into<Error>,
 {
     type Error = EncoderError<B::Error>;
 

actix-http/src/error.rs

@@ -196,7 +196,7 @@ pub enum ParseError {
     #[display(fmt = "IO error: {}", _0)]
     Io(io::Error),
 
-    /// Parsing a field as string failed
+    /// Parsing a field as string failed.
     #[display(fmt = "UTF8 error: {}", _0)]
     Utf8(Utf8Error),
 }

actix-http/src/h1/chunked.rs

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

actix-http/src/h1/decoder.rs

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

actix-http/src/h1/dispatcher.rs

@@ -1060,7 +1060,7 @@ mod tests {
     fn stabilize_date_header(payload: &mut [u8]) {
         let mut from = 0;
 
-        while let Some(pos) = find_slice(&payload, b"date", from) {
+        while let Some(pos) = find_slice(payload, b"date", from) {
             payload[(from + pos)..(from + pos + 35)]
                 .copy_from_slice(b"date: Thu, 01 Jan 1970 12:34:56 UTC");
             from += 35;

actix-http/src/h1/encoder.rs

@@ -81,6 +81,7 @@ pub(crate) trait MessageType: Sized {
         match length {
             BodySize::Stream => {
                 if chunked {
+                    skip_len = true;
                     if camel_case {
                         dst.put_slice(b"\r\nTransfer-Encoding: chunked\r\n")
                     } else {
@@ -174,7 +175,7 @@ pub(crate) trait MessageType: Sized {
                 unsafe {
                     if camel_case {
                         // use Camel-Case headers
-                        write_camel_case(k, from_raw_parts_mut(buf, k_len));
+                        write_camel_case(k, buf, k_len);
                     } else {
                         write_data(k, buf, k_len);
                     }
@@ -472,15 +473,22 @@ impl TransferEncoding {
 }
 
 /// # Safety
-/// Callers must ensure that the given length matches given value length.
+/// Callers must ensure that the given `len` matches the given `value` length and that `buf` is
+/// valid for writes of at least `len` bytes.
 unsafe fn write_data(value: &[u8], buf: *mut u8, len: usize) {
     debug_assert_eq!(value.len(), len);
     copy_nonoverlapping(value.as_ptr(), buf, len);
 }
 
-fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
+/// # Safety
+/// Callers must ensure that the given `len` matches the given `value` length and that `buf` is
+/// valid for writes of at least `len` bytes.
+unsafe fn write_camel_case(value: &[u8], buf: *mut u8, len: usize) {
     // first copy entire (potentially wrong) slice to output
-    buffer[..value.len()].copy_from_slice(value);
+    write_data(value, buf, len);
+
+    // SAFETY: We just initialized the buffer with `value`
+    let buffer = from_raw_parts_mut(buf, len);
 
     let mut iter = value.iter();
 

actix-http/src/h1/mod.rs

@@ -1,6 +1,8 @@
 //! HTTP/1 protocol implementation.
+
 use bytes::{Bytes, BytesMut};
 
+mod chunked;
 mod client;
 mod codec;
 mod decoder;

actix-http/src/h1/utils.rs

@@ -63,7 +63,6 @@ where
                         .is_write_buf_full()
                 {
                     let next =
-                        // TODO: MSRV 1.51: poll_map_err
                         match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx) {
                             Poll::Ready(Some(Ok(item))) => Poll::Ready(Some(item)),
                             Poll::Ready(Some(Err(err))) => {

actix-http/src/header/map.rs

@@ -684,7 +684,7 @@ impl<'a> Iterator for Iter<'a> {
 
     fn next(&mut self) -> Option<Self::Item> {
         // handle in-progress multi value lists first
-        if let Some((ref name, ref mut vals)) = self.multi_inner {
+        if let Some((name, ref mut vals)) = self.multi_inner {
             match vals.get(self.multi_idx) {
                 Some(val) => {
                     self.multi_idx += 1;

actix-http/src/lib.rs

@@ -14,7 +14,7 @@
 //! [rustls]: https://crates.io/crates/rustls
 //! [trust-dns]: https://crates.io/crates/trust-dns
 
-#![deny(rust_2018_idioms, nonstandard_style)]
+#![deny(rust_2018_idioms, nonstandard_style, clippy::uninit_assumed_init)]
 #![allow(
     clippy::type_complexity,
     clippy::too_many_arguments,

actix-http/src/message.rs

@@ -209,7 +209,7 @@ impl RequestHeadType {
 impl AsRef<RequestHead> for RequestHeadType {
     fn as_ref(&self) -> &RequestHead {
         match self {
-            RequestHeadType::Owned(head) => &head,
+            RequestHeadType::Owned(head) => head,
             RequestHeadType::Rc(head, _) => head.as_ref(),
         }
     }
@@ -363,7 +363,7 @@ impl<T: Head> std::ops::Deref for Message<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        &self.head.as_ref()
+        self.head.as_ref()
     }
 }
 

actix-multipart/CHANGES.md

@@ -1,6 +1,7 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+* Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 0.4.0-beta.5 - 2021-06-17

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-beta.5)](https://docs.rs/actix-multipart/0.4.0-beta.5)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Version](https://img.shields.io/badge/rustc-1.51+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.51.html)
 ![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-beta.5/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.5)
@@ -14,4 +14,4 @@
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-multipart)
-- Minimum Supported Rust Version (MSRV): 1.46.0
+- Minimum Supported Rust Version (MSRV): 1.51.0

actix-router/CHANGES.md

@@ -0,0 +1,124 @@
+# Changes
+
+## Unreleased - 2021-xx-xx
+* Introduce `ResourceDef::join`. [#380]
+* Disallow prefix routes with tail segments. [#379]
+* Enforce path separators on dynamic prefixes. [#378]
+* Improve malformed path error message. [#384]
+* Prefix segments now always end with with a segment delimiter or end-of-input. [#2355]
+* Prefix segments with trailing slashes define a trailing empty segment. [#2355]
+* Minimum supported Rust version (MSRV) is now 1.51.
+
+[#378]: https://github.com/actix/actix-net/pull/378
+[#379]: https://github.com/actix/actix-net/pull/379
+[#380]: https://github.com/actix/actix-net/pull/380
+[#384]: https://github.com/actix/actix-net/pull/384
+[#2355]: https://github.com/actix/actix-web/pull/2355
+
+
+## 0.5.0-beta.1 - 2021-07-20
+* Fix a bug in multi-patterns where static patterns are interpreted as regex. [#366]
+* Introduce `ResourceDef::pattern_iter` to get an iterator over all patterns in a multi-pattern resource. [#373]
+* Fix segment interpolation leaving `Path` in unintended state after matching. [#368]
+* Fix `ResourceDef` `PartialEq` implementation. [#373]
+* Re-work `IntoPatterns` trait, adding a `Patterns` enum. [#372]
+* Implement `IntoPatterns` for `bytestring::ByteString`. [#372]
+* Rename `Path::{len => segment_count}` to be more descriptive of it's purpose. [#370]
+* Rename `ResourceDef::{resource_path => resource_path_from_iter}`. [#371]
+* `ResourceDef::resource_path_from_iter` now takes an `IntoIterator`. [#373]
+* Rename `ResourceDef::{resource_path_named => resource_path_from_map}`. [#371]
+* Rename `ResourceDef::{is_prefix_match => find_match}`. [#373]
+* Rename `ResourceDef::{match_path => capture_match_info}`. [#373]
+* Rename `ResourceDef::{match_path_checked => capture_match_info_fn}`. [#373]
+* Remove `ResourceDef::name_mut` and introduce `ResourceDef::set_name`. [#373]
+* Rename `Router::{*_checked => *_fn}`. [#373]
+* Return type of `ResourceDef::name` is now `Option<&str>`. [#373]
+* Return type of `ResourceDef::pattern` is now `Option<&str>`. [#373]
+
+[#368]: https://github.com/actix/actix-net/pull/368
+[#366]: https://github.com/actix/actix-net/pull/366
+[#368]: https://github.com/actix/actix-net/pull/368
+[#370]: https://github.com/actix/actix-net/pull/370
+[#371]: https://github.com/actix/actix-net/pull/371
+[#372]: https://github.com/actix/actix-net/pull/372
+[#373]: https://github.com/actix/actix-net/pull/373
+
+
+## 0.4.0 - 2021-06-06
+* When matching path parameters, `%25` is now kept in the percent-encoded form; no longer decoded to `%`. [#357]
+* Path tail patterns now match new lines (`\n`) in request URL. [#360]
+* Fixed a safety bug where `Path` could return a malformed string after percent decoding. [#359]
+* Methods `Path::{add, add_static}` now take `impl Into<Cow<'static, str>>`. [#345]
+
+[#345]: https://github.com/actix/actix-net/pull/345
+[#357]: https://github.com/actix/actix-net/pull/357
+[#359]: https://github.com/actix/actix-net/pull/359
+[#360]: https://github.com/actix/actix-net/pull/360
+
+
+## 0.3.0 - 2019-12-31
+* Version was yanked previously. See https://crates.io/crates/actix-router/0.3.0
+
+
+## 0.2.7 - 2021-02-06
+* Add `Router::recognize_checked` [#247]
+
+[#247]: https://github.com/actix/actix-net/pull/247
+
+
+## 0.2.6 - 2021-01-09
+* Use `bytestring` version range compatible with Bytes v1.0. [#246]
+
+[#246]: https://github.com/actix/actix-net/pull/246
+
+
+## 0.2.5 - 2020-09-20
+* Fix `from_hex()` method
+
+
+## 0.2.4 - 2019-12-31
+* Add `ResourceDef::resource_path_named()` path generation method
+
+
+## 0.2.3 - 2019-12-25
+* Add impl `IntoPattern` for `&String`
+
+
+## 0.2.2 - 2019-12-25
+* Use `IntoPattern` for `RouterBuilder::path()`
+
+
+## 0.2.1 - 2019-12-25
+* Add `IntoPattern` trait
+* Add multi-pattern resources
+
+
+## 0.2.0 - 2019-12-07
+* Update http to 0.2
+* Update regex to 1.3
+* Use bytestring instead of string
+
+
+## 0.1.5 - 2019-05-15
+* Remove debug prints
+
+
+## 0.1.4 - 2019-05-15
+* Fix checked resource match
+
+
+## 0.1.3 - 2019-04-22
+* Added support for `remainder match` (i.e "/path/{tail}*")
+
+
+## 0.1.2 - 2019-04-07
+* Export `Quoter` type
+* Allow to reset `Path` instance
+
+
+## 0.1.1 - 2019-04-03
+* Get dynamic segment by name instead of iterator.
+
+
+## 0.1.0 - 2019-03-09
+* Initial release

actix-router/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "actix-router"
+version = "0.5.0-beta.1"
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Ali MJ Al-Nasrawy <alimjalnasrawy@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+]
+description = "Resource path matching and router"
+keywords = ["actix", "router", "routing"]
+repository = "https://github.com/actix/actix-net.git"
+license = "MIT OR Apache-2.0"
+edition = "2018"
+
+[lib]
+name = "actix_router"
+path = "src/lib.rs"
+
+[features]
+default = ["http"]
+
+[dependencies]
+bytestring = ">=0.1.5, <2"
+firestorm = "0.4"
+http = { version = "0.2.3", optional = true }
+log = "0.4"
+regex = "1.5"
+serde = "1"
+
+[dev-dependencies]
+criterion = { version = "0.3", features = ["html_reports"] }
+firestorm = { version = "0.4", features = ["enable_system_time"] }
+http = "0.2.3"
+serde = { version = "1", features = ["derive"] }
+
+[[bench]]
+name = "router"
+harness = false

actix-router/LICENSE-APACHE

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

actix-router/LICENSE-MIT

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

actix-router/benches/router.rs

@@ -0,0 +1,194 @@
+//! Based on https://github.com/ibraheemdev/matchit/blob/master/benches/bench.rs
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+macro_rules! register {
+    (colon) => {{
+        register!(finish => ":p1", ":p2", ":p3", ":p4")
+    }};
+    (brackets) => {{
+        register!(finish => "{p1}", "{p2}", "{p3}", "{p4}")
+    }};
+    (regex) => {{
+        register!(finish => "(.*)", "(.*)", "(.*)", "(.*)")
+    }};
+    (finish => $p1:literal, $p2:literal, $p3:literal, $p4:literal) => {{
+        let arr = [
+            concat!("/authorizations"),
+            concat!("/authorizations/", $p1),
+            concat!("/applications/", $p1, "/tokens/", $p2),
+            concat!("/events"),
+            concat!("/repos/", $p1, "/", $p2, "/events"),
+            concat!("/networks/", $p1, "/", $p2, "/events"),
+            concat!("/orgs/", $p1, "/events"),
+            concat!("/users/", $p1, "/received_events"),
+            concat!("/users/", $p1, "/received_events/public"),
+            concat!("/users/", $p1, "/events"),
+            concat!("/users/", $p1, "/events/public"),
+            concat!("/users/", $p1, "/events/orgs/", $p2),
+            concat!("/feeds"),
+            concat!("/notifications"),
+            concat!("/repos/", $p1, "/", $p2, "/notifications"),
+            concat!("/notifications/threads/", $p1),
+            concat!("/notifications/threads/", $p1, "/subscription"),
+            concat!("/repos/", $p1, "/", $p2, "/stargazers"),
+            concat!("/users/", $p1, "/starred"),
+            concat!("/user/starred"),
+            concat!("/user/starred/", $p1, "/", $p2),
+            concat!("/repos/", $p1, "/", $p2, "/subscribers"),
+            concat!("/users/", $p1, "/subscriptions"),
+            concat!("/user/subscriptions"),
+            concat!("/repos/", $p1, "/", $p2, "/subscription"),
+            concat!("/user/subscriptions/", $p1, "/", $p2),
+            concat!("/users/", $p1, "/gists"),
+            concat!("/gists"),
+            concat!("/gists/", $p1),
+            concat!("/gists/", $p1, "/star"),
+            concat!("/repos/", $p1, "/", $p2, "/git/blobs/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/git/commits/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/git/refs"),
+            concat!("/repos/", $p1, "/", $p2, "/git/tags/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/git/trees/", $p3),
+            concat!("/issues"),
+            concat!("/user/issues"),
+            concat!("/orgs/", $p1, "/issues"),
+            concat!("/repos/", $p1, "/", $p2, "/issues"),
+            concat!("/repos/", $p1, "/", $p2, "/issues/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/assignees"),
+            concat!("/repos/", $p1, "/", $p2, "/assignees/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/issues/", $p3, "/comments"),
+            concat!("/repos/", $p1, "/", $p2, "/issues/", $p3, "/events"),
+            concat!("/repos/", $p1, "/", $p2, "/labels"),
+            concat!("/repos/", $p1, "/", $p2, "/labels/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/issues/", $p3, "/labels"),
+            concat!("/repos/", $p1, "/", $p2, "/milestones/", $p3, "/labels"),
+            concat!("/repos/", $p1, "/", $p2, "/milestones/"),
+            concat!("/repos/", $p1, "/", $p2, "/milestones/", $p3),
+            concat!("/emojis"),
+            concat!("/gitignore/templates"),
+            concat!("/gitignore/templates/", $p1),
+            concat!("/meta"),
+            concat!("/rate_limit"),
+            concat!("/users/", $p1, "/orgs"),
+            concat!("/user/orgs"),
+            concat!("/orgs/", $p1),
+            concat!("/orgs/", $p1, "/members"),
+            concat!("/orgs/", $p1, "/members", $p2),
+            concat!("/orgs/", $p1, "/public_members"),
+            concat!("/orgs/", $p1, "/public_members/", $p2),
+            concat!("/orgs/", $p1, "/teams"),
+            concat!("/teams/", $p1),
+            concat!("/teams/", $p1, "/members"),
+            concat!("/teams/", $p1, "/members", $p2),
+            concat!("/teams/", $p1, "/repos"),
+            concat!("/teams/", $p1, "/repos/", $p2, "/", $p3),
+            concat!("/user/teams"),
+            concat!("/repos/", $p1, "/", $p2, "/pulls"),
+            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3, "/commits"),
+            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3, "/files"),
+            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3, "/merge"),
+            concat!("/repos/", $p1, "/", $p2, "/pulls/", $p3, "/comments"),
+            concat!("/user/repos"),
+            concat!("/users/", $p1, "/repos"),
+            concat!("/orgs/", $p1, "/repos"),
+            concat!("/repositories"),
+            concat!("/repos/", $p1, "/", $p2),
+            concat!("/repos/", $p1, "/", $p2, "/contributors"),
+            concat!("/repos/", $p1, "/", $p2, "/languages"),
+            concat!("/repos/", $p1, "/", $p2, "/teams"),
+            concat!("/repos/", $p1, "/", $p2, "/tags"),
+            concat!("/repos/", $p1, "/", $p2, "/branches"),
+            concat!("/repos/", $p1, "/", $p2, "/branches/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/collaborators"),
+            concat!("/repos/", $p1, "/", $p2, "/collaborators/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/comments"),
+            concat!("/repos/", $p1, "/", $p2, "/commits/", $p3, "/comments"),
+            concat!("/repos/", $p1, "/", $p2, "/commits"),
+            concat!("/repos/", $p1, "/", $p2, "/commits/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/readme"),
+            concat!("/repos/", $p1, "/", $p2, "/keys"),
+            concat!("/repos/", $p1, "/", $p2, "/keys", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/downloads"),
+            concat!("/repos/", $p1, "/", $p2, "/downloads", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/forks"),
+            concat!("/repos/", $p1, "/", $p2, "/hooks"),
+            concat!("/repos/", $p1, "/", $p2, "/hooks", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/releases"),
+            concat!("/repos/", $p1, "/", $p2, "/releases/", $p3),
+            concat!("/repos/", $p1, "/", $p2, "/releases/", $p3, "/assets"),
+            concat!("/repos/", $p1, "/", $p2, "/stats/contributors"),
+            concat!("/repos/", $p1, "/", $p2, "/stats/commit_activity"),
+            concat!("/repos/", $p1, "/", $p2, "/stats/code_frequency"),
+            concat!("/repos/", $p1, "/", $p2, "/stats/participation"),
+            concat!("/repos/", $p1, "/", $p2, "/stats/punch_card"),
+            concat!("/repos/", $p1, "/", $p2, "/statuses/", $p3),
+            concat!("/search/repositories"),
+            concat!("/search/code"),
+            concat!("/search/issues"),
+            concat!("/search/users"),
+            concat!("/legacy/issues/search/", $p1, "/", $p2, "/", $p3, "/", $p4),
+            concat!("/legacy/repos/search/", $p1),
+            concat!("/legacy/user/search/", $p1),
+            concat!("/legacy/user/email/", $p1),
+            concat!("/users/", $p1),
+            concat!("/user"),
+            concat!("/users"),
+            concat!("/user/emails"),
+            concat!("/users/", $p1, "/followers"),
+            concat!("/user/followers"),
+            concat!("/users/", $p1, "/following"),
+            concat!("/user/following"),
+            concat!("/user/following/", $p1),
+            concat!("/users/", $p1, "/following", $p2),
+            concat!("/users/", $p1, "/keys"),
+            concat!("/user/keys"),
+            concat!("/user/keys/", $p1),
+        ];
+        std::array::IntoIter::new(arr)
+    }};
+}
+
+fn call() -> impl Iterator<Item = &'static str> {
+    let arr = [
+        "/authorizations",
+        "/user/repos",
+        "/repos/rust-lang/rust/stargazers",
+        "/orgs/rust-lang/public_members/nikomatsakis",
+        "/repos/rust-lang/rust/releases/1.51.0",
+    ];
+
+    std::array::IntoIter::new(arr)
+}
+
+fn compare_routers(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Compare Routers");
+
+    let mut actix = actix_router::Router::<bool>::build();
+    for route in register!(brackets) {
+        actix.path(route, true);
+    }
+    let actix = actix.finish();
+    group.bench_function("actix", |b| {
+        b.iter(|| {
+            for route in call() {
+                let mut path = actix_router::Path::new(route);
+                black_box(actix.recognize(&mut path).unwrap());
+            }
+        });
+    });
+
+    let regex_set = regex::RegexSet::new(register!(regex)).unwrap();
+    group.bench_function("regex", |b| {
+        b.iter(|| {
+            for route in call() {
+                black_box(regex_set.matches(route));
+            }
+        });
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, compare_routers);
+criterion_main!(benches);

actix-router/examples/flamegraph.rs

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

actix-router/src/de.rs

@@ -0,0 +1,723 @@
+use serde::de::{self, Deserializer, Error as DeError, Visitor};
+use serde::forward_to_deserialize_any;
+
+use crate::path::{Path, PathIter};
+use crate::ResourcePath;
+
+macro_rules! unsupported_type {
+    ($trait_fn:ident, $name:expr) => {
+        fn $trait_fn<V>(self, _: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            Err(de::value::Error::custom(concat!(
+                "unsupported type: ",
+                $name
+            )))
+        }
+    };
+}
+
+macro_rules! parse_single_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            if self.path.segment_count() != 1 {
+                Err(de::value::Error::custom(
+                    format!(
+                        "wrong number of parameters: {} expected 1",
+                        self.path.segment_count()
+                    )
+                    .as_str(),
+                ))
+            } else {
+                let v = self.path[0].parse().map_err(|_| {
+                    de::value::Error::custom(format!(
+                        "can not parse {:?} to a {}",
+                        &self.path[0], $tp
+                    ))
+                })?;
+                visitor.$visit_fn(v)
+            }
+        }
+    };
+}
+
+pub struct PathDeserializer<'de, T: ResourcePath> {
+    path: &'de Path<T>,
+}
+
+impl<'de, T: ResourcePath + 'de> PathDeserializer<'de, T> {
+    pub fn new(path: &'de Path<T>) -> Self {
+        PathDeserializer { path }
+    }
+}
+
+impl<'de, T: ResourcePath + 'de> Deserializer<'de> for PathDeserializer<'de, T> {
+    type Error = de::value::Error;
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_map(ParamsDeserializer {
+            params: self.path.iter(),
+            current: None,
+        })
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_map(visitor)
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.segment_count() < len {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected {}",
+                    self.path.segment_count(),
+                    len
+                )
+                .as_str(),
+            ))
+        } else {
+            visitor.visit_seq(ParamsSeq {
+                params: self.path.iter(),
+            })
+        }
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _: &'static str,
+        len: usize,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.segment_count() < len {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected {}",
+                    self.path.segment_count(),
+                    len
+                )
+                .as_str(),
+            ))
+        } else {
+            visitor.visit_seq(ParamsSeq {
+                params: self.path.iter(),
+            })
+        }
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.is_empty() {
+            Err(de::value::Error::custom("expected at least one parameters"))
+        } else {
+            visitor.visit_enum(ValueEnum {
+                value: &self.path[0],
+            })
+        }
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.segment_count() != 1 {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected 1",
+                    self.path.segment_count()
+                )
+                .as_str(),
+            ))
+        } else {
+            visitor.visit_str(&self.path[0])
+        }
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_seq(ParamsSeq {
+            params: self.path.iter(),
+        })
+    }
+
+    unsupported_type!(deserialize_any, "'any'");
+    unsupported_type!(deserialize_bytes, "bytes");
+    unsupported_type!(deserialize_option, "Option<T>");
+    unsupported_type!(deserialize_identifier, "identifier");
+    unsupported_type!(deserialize_ignored_any, "ignored_any");
+
+    parse_single_value!(deserialize_bool, visit_bool, "bool");
+    parse_single_value!(deserialize_i8, visit_i8, "i8");
+    parse_single_value!(deserialize_i16, visit_i16, "i16");
+    parse_single_value!(deserialize_i32, visit_i32, "i32");
+    parse_single_value!(deserialize_i64, visit_i64, "i64");
+    parse_single_value!(deserialize_u8, visit_u8, "u8");
+    parse_single_value!(deserialize_u16, visit_u16, "u16");
+    parse_single_value!(deserialize_u32, visit_u32, "u32");
+    parse_single_value!(deserialize_u64, visit_u64, "u64");
+    parse_single_value!(deserialize_f32, visit_f32, "f32");
+    parse_single_value!(deserialize_f64, visit_f64, "f64");
+    parse_single_value!(deserialize_string, visit_string, "String");
+    parse_single_value!(deserialize_byte_buf, visit_string, "String");
+    parse_single_value!(deserialize_char, visit_char, "char");
+}
+
+struct ParamsDeserializer<'de, T: ResourcePath> {
+    params: PathIter<'de, T>,
+    current: Option<(&'de str, &'de str)>,
+}
+
+impl<'de, T: ResourcePath> de::MapAccess<'de> for ParamsDeserializer<'de, T> {
+    type Error = de::value::Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+    where
+        K: de::DeserializeSeed<'de>,
+    {
+        self.current = self.params.next().map(|ref item| (item.0, item.1));
+        match self.current {
+            Some((key, _)) => Ok(Some(seed.deserialize(Key { key })?)),
+            None => Ok(None),
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        if let Some((_, value)) = self.current.take() {
+            seed.deserialize(Value { value })
+        } else {
+            Err(de::value::Error::custom("unexpected item"))
+        }
+    }
+}
+
+struct Key<'de> {
+    key: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Key<'de> {
+    type Error = de::value::Error;
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_str(self.key)
+    }
+
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("Unexpected"))
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+            byte_buf option unit unit_struct newtype_struct seq tuple
+            tuple_struct map struct enum ignored_any
+    }
+}
+
+macro_rules! parse_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            let v = self.value.parse().map_err(|_| {
+                de::value::Error::custom(format!("can not parse {:?} to a {}", self.value, $tp))
+            })?;
+            visitor.$visit_fn(v)
+        }
+    };
+}
+
+struct Value<'de> {
+    value: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Value<'de> {
+    type Error = de::value::Error;
+
+    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_i64, visit_i64, "i64");
+    parse_value!(deserialize_u8, visit_u8, "u8");
+    parse_value!(deserialize_u16, visit_u16, "u16");
+    parse_value!(deserialize_u32, visit_u32, "u32");
+    parse_value!(deserialize_u64, visit_u64, "u64");
+    parse_value!(deserialize_f32, visit_f32, "f32");
+    parse_value!(deserialize_f64, visit_f64, "f64");
+    parse_value!(deserialize_string, visit_string, "String");
+    parse_value!(deserialize_byte_buf, visit_string, "String");
+    parse_value!(deserialize_char, visit_char, "char");
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_bytes(self.value.as_bytes())
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_str(self.value)
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_some(self)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_enum(ValueEnum { value: self.value })
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: tuple"))
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: struct"))
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _: &'static str,
+        _: usize,
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: tuple struct"))
+    }
+
+    unsupported_type!(deserialize_any, "any");
+    unsupported_type!(deserialize_seq, "seq");
+    unsupported_type!(deserialize_map, "map");
+    unsupported_type!(deserialize_identifier, "identifier");
+}
+
+struct ParamsSeq<'de, T: ResourcePath> {
+    params: PathIter<'de, T>,
+}
+
+impl<'de, T: ResourcePath> de::SeqAccess<'de> for ParamsSeq<'de, T> {
+    type Error = de::value::Error;
+
+    fn next_element_seed<U>(&mut self, seed: U) -> Result<Option<U::Value>, Self::Error>
+    where
+        U: de::DeserializeSeed<'de>,
+    {
+        match self.params.next() {
+            Some(item) => Ok(Some(seed.deserialize(Value { value: item.1 })?)),
+            None => Ok(None),
+        }
+    }
+}
+
+struct ValueEnum<'de> {
+    value: &'de str,
+}
+
+impl<'de> de::EnumAccess<'de> for ValueEnum<'de> {
+    type Error = de::value::Error;
+    type Variant = UnitVariant;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        Ok((seed.deserialize(Key { key: self.value })?, UnitVariant))
+    }
+}
+
+struct UnitVariant;
+
+impl<'de> de::VariantAccess<'de> for UnitVariant {
+    type Error = de::value::Error;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn struct_variant<V>(
+        self,
+        _: &'static [&'static str],
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde::{de, Deserialize};
+
+    use super::*;
+    use crate::path::Path;
+    use crate::router::Router;
+
+    #[derive(Deserialize)]
+    struct MyStruct {
+        key: String,
+        value: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Id {
+        _id: String,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Test1(String, u32);
+
+    #[derive(Debug, Deserialize)]
+    struct Test2 {
+        key: String,
+        value: u32,
+    }
+
+    #[derive(Debug, Deserialize, PartialEq)]
+    #[serde(rename_all = "lowercase")]
+    enum TestEnum {
+        Val1,
+        Val2,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Test3 {
+        val: TestEnum,
+    }
+
+    #[test]
+    fn test_request_extract() {
+        let mut router = Router::<()>::build();
+        router.path("/{key}/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/user1/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: MyStruct = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, "user1");
+
+        let s: (String, String) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, "user1");
+
+        let mut router = Router::<()>::build();
+        router.path("/{key}/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/32/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: Test1 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let s: Test2 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, 32);
+
+        let s: (String, u8) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let res: Vec<String> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(res[0], "name".to_owned());
+        assert_eq!(res[1], "32".to_owned());
+    }
+
+    #[test]
+    fn test_extract_path_single() {
+        let mut router = Router::<()>::build();
+        router.path("/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/32/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: i8 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, 32);
+    }
+
+    #[test]
+    fn test_extract_enum() {
+        let mut router = Router::<()>::build();
+        router.path("/{val}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: TestEnum = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, TestEnum::Val1);
+
+        let mut router = Router::<()>::build();
+        router.path("/{val1}/{val2}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/val2/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: (TestEnum, TestEnum) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, (TestEnum::Val1, TestEnum::Val2));
+    }
+
+    #[test]
+    fn test_extract_enum_value() {
+        let mut router = Router::<()>::build();
+        router.path("/{val}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: Test3 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i.val, TestEnum::Val1);
+
+        let mut path = Path::new("/val3/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: Result<Test3, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(i.is_err());
+        assert!(format!("{:?}", i).contains("unknown variant"));
+    }
+
+    #[test]
+    fn test_extract_errors() {
+        let mut router = Router::<()>::build();
+        router.path("/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: Result<Test1, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("wrong number of parameters"));
+
+        let s: Result<Test2, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("can not parse"));
+
+        let s: Result<(String, String), de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("wrong number of parameters"));
+
+        let s: Result<u32, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("can not parse"));
+    }
+
+    // #[test]
+    // fn test_extract_path_decode() {
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{value}/")));
+
+    //     macro_rules! test_single_value {
+    //         ($value:expr, $expected:expr) => {{
+    //             let req = TestRequest::with_uri($value).finish();
+    //             let info = router.recognize(&req, &(), 0);
+    //             let req = req.with_route_info(info);
+    //             assert_eq!(
+    //                 *Path::<String>::from_request(&req, &PathConfig::default()).unwrap(),
+    //                 $expected
+    //             );
+    //         }};
+    //     }
+
+    //     test_single_value!("/%25/", "%");
+    //     test_single_value!("/%40%C2%A3%24%25%5E%26%2B%3D/", "@£$%^&+=");
+    //     test_single_value!("/%2B/", "+");
+    //     test_single_value!("/%252B/", "%2B");
+    //     test_single_value!("/%2F/", "/");
+    //     test_single_value!("/%252F/", "%2F");
+    //     test_single_value!(
+    //         "/http%3A%2F%2Flocalhost%3A80%2Ffoo/",
+    //         "http://localhost:80/foo"
+    //     );
+    //     test_single_value!("/%2Fvar%2Flog%2Fsyslog/", "/var/log/syslog");
+    //     test_single_value!(
+    //         "/http%3A%2F%2Flocalhost%3A80%2Ffile%2F%252Fvar%252Flog%252Fsyslog/",
+    //         "http://localhost:80/file/%2Fvar%2Flog%2Fsyslog"
+    //     );
+
+    //     let req = TestRequest::with_uri("/%25/7/?id=test").finish();
+
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{key}/{value}/")));
+    //     let info = router.recognize(&req, &(), 0);
+    //     let req = req.with_route_info(info);
+
+    //     let s = Path::<Test2>::from_request(&req, &PathConfig::default()).unwrap();
+    //     assert_eq!(s.key, "%");
+    //     assert_eq!(s.value, 7);
+
+    //     let s = Path::<(String, String)>::from_request(&req, &PathConfig::default()).unwrap();
+    //     assert_eq!(s.0, "%");
+    //     assert_eq!(s.1, "7");
+    // }
+
+    // #[test]
+    // fn test_extract_path_no_decode() {
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{value}/")));
+
+    //     let req = TestRequest::with_uri("/%25/").finish();
+    //     let info = router.recognize(&req, &(), 0);
+    //     let req = req.with_route_info(info);
+    //     assert_eq!(
+    //         *Path::<String>::from_request(&req, &&PathConfig::default().disable_decoding())
+    //             .unwrap(),
+    //         "%25"
+    //     );
+    // }
+}

actix-router/src/lib.rs

@@ -0,0 +1,149 @@
+//! Resource path matching and router.
+
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
+mod de;
+mod path;
+mod resource;
+mod router;
+
+pub use self::de::PathDeserializer;
+pub use self::path::Path;
+pub use self::resource::ResourceDef;
+pub use self::router::{ResourceInfo, Router, RouterBuilder};
+
+// TODO: this trait is necessary, document it
+// see impl Resource for ServiceRequest
+pub trait Resource<T: ResourcePath> {
+    fn resource_path(&mut self) -> &mut Path<T>;
+}
+
+pub trait ResourcePath {
+    fn path(&self) -> &str;
+}
+
+impl ResourcePath for String {
+    fn path(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'a> ResourcePath for &'a str {
+    fn path(&self) -> &str {
+        self
+    }
+}
+
+impl ResourcePath for bytestring::ByteString {
+    fn path(&self) -> &str {
+        &*self
+    }
+}
+
+/// One or many patterns.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Patterns {
+    Single(String),
+    List(Vec<String>),
+}
+
+impl Patterns {
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Patterns::Single(_) => false,
+            Patterns::List(pats) => pats.is_empty(),
+        }
+    }
+}
+
+/// Helper trait for type that could be converted to one or more path pattern.
+pub trait IntoPatterns {
+    fn patterns(&self) -> Patterns;
+}
+
+impl IntoPatterns for String {
+    fn patterns(&self) -> Patterns {
+        Patterns::Single(self.clone())
+    }
+}
+
+impl<'a> IntoPatterns for &'a String {
+    fn patterns(&self) -> Patterns {
+        Patterns::Single((*self).clone())
+    }
+}
+
+impl<'a> IntoPatterns for &'a str {
+    fn patterns(&self) -> Patterns {
+        Patterns::Single((*self).to_owned())
+    }
+}
+
+impl IntoPatterns for bytestring::ByteString {
+    fn patterns(&self) -> Patterns {
+        Patterns::Single(self.to_string())
+    }
+}
+
+impl IntoPatterns for Patterns {
+    fn patterns(&self) -> Patterns {
+        self.clone()
+    }
+}
+
+impl<T: AsRef<str>> IntoPatterns for Vec<T> {
+    fn patterns(&self) -> Patterns {
+        let mut patterns = self.iter().map(|v| v.as_ref().to_owned());
+
+        match patterns.size_hint() {
+            (1, _) => Patterns::Single(patterns.next().unwrap()),
+            _ => Patterns::List(patterns.collect()),
+        }
+    }
+}
+
+macro_rules! array_patterns_single (($tp:ty) => {
+    impl IntoPatterns for [$tp; 1] {
+        fn patterns(&self) -> Patterns {
+            Patterns::Single(self[0].to_owned())
+        }
+    }
+});
+
+macro_rules! array_patterns_multiple (($tp:ty, $str_fn:expr, $($num:tt) +) => {
+    // for each array length specified in $num
+    $(
+        impl IntoPatterns for [$tp; $num] {
+            fn patterns(&self) -> Patterns {
+                Patterns::List(self.iter().map($str_fn).collect())
+            }
+        }
+    )+
+});
+
+array_patterns_single!(&str);
+array_patterns_multiple!(&str, |&v| v.to_owned(), 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);
+
+array_patterns_single!(String);
+array_patterns_multiple!(String, |v| v.clone(), 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);
+
+#[cfg(feature = "http")]
+mod url;
+
+#[cfg(feature = "http")]
+pub use self::url::{Quoter, Url};
+
+#[cfg(feature = "http")]
+mod http_impls {
+    use http::Uri;
+
+    use super::ResourcePath;
+
+    impl ResourcePath for Uri {
+        fn path(&self) -> &str {
+            self.path()
+        }
+    }
+}

actix-router/src/path.rs

@@ -0,0 +1,220 @@
+use std::borrow::Cow;
+use std::ops::Index;
+
+use firestorm::profile_method;
+use serde::de;
+
+use crate::{de::PathDeserializer, Resource, ResourcePath};
+
+#[derive(Debug, Clone)]
+pub(crate) enum PathItem {
+    Static(Cow<'static, str>),
+    Segment(u16, u16),
+}
+
+impl Default for PathItem {
+    fn default() -> Self {
+        Self::Static(Cow::Borrowed(""))
+    }
+}
+
+/// Resource path match information.
+///
+/// If resource path contains variable patterns, `Path` stores them.
+#[derive(Debug, Clone, Default)]
+pub struct Path<T> {
+    path: T,
+    pub(crate) skip: u16,
+    pub(crate) segments: Vec<(Cow<'static, str>, PathItem)>,
+}
+
+impl<T: ResourcePath> Path<T> {
+    pub fn new(path: T) -> Path<T> {
+        Path {
+            path,
+            skip: 0,
+            segments: Vec::new(),
+        }
+    }
+
+    /// Get reference to inner path instance.
+    #[inline]
+    pub fn get_ref(&self) -> &T {
+        &self.path
+    }
+
+    /// Get mutable reference to inner path instance.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.path
+    }
+
+    /// Path.
+    #[inline]
+    pub fn path(&self) -> &str {
+        profile_method!(path);
+
+        let skip = self.skip as usize;
+        let path = self.path.path();
+        if skip <= path.len() {
+            &path[skip..]
+        } else {
+            ""
+        }
+    }
+
+    /// Set new path.
+    #[inline]
+    pub fn set(&mut self, path: T) {
+        self.skip = 0;
+        self.path = path;
+        self.segments.clear();
+    }
+
+    /// Reset state.
+    #[inline]
+    pub fn reset(&mut self) {
+        self.skip = 0;
+        self.segments.clear();
+    }
+
+    /// Skip first `n` chars in path.
+    #[inline]
+    pub fn skip(&mut self, n: u16) {
+        self.skip += n;
+    }
+
+    pub(crate) fn add(&mut self, name: impl Into<Cow<'static, str>>, value: PathItem) {
+        profile_method!(add);
+
+        match value {
+            PathItem::Static(s) => self.segments.push((name.into(), PathItem::Static(s))),
+            PathItem::Segment(begin, end) => self.segments.push((
+                name.into(),
+                PathItem::Segment(self.skip + begin, self.skip + end),
+            )),
+        }
+    }
+
+    #[doc(hidden)]
+    pub fn add_static(
+        &mut self,
+        name: impl Into<Cow<'static, str>>,
+        value: impl Into<Cow<'static, str>>,
+    ) {
+        self.segments
+            .push((name.into(), PathItem::Static(value.into())));
+    }
+
+    /// Check if there are any matched patterns.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.segments.is_empty()
+    }
+
+    /// Returns number of interpolated segments.
+    #[inline]
+    pub fn segment_count(&self) -> usize {
+        self.segments.len()
+    }
+
+    /// Get matched parameter by name without type conversion
+    pub fn get(&self, name: &str) -> Option<&str> {
+        profile_method!(get);
+
+        for (seg_name, val) in self.segments.iter() {
+            if name == seg_name {
+                return match val {
+                    PathItem::Static(ref s) => Some(s),
+                    PathItem::Segment(s, e) => {
+                        Some(&self.path.path()[(*s as usize)..(*e as usize)])
+                    }
+                };
+            }
+        }
+
+        None
+    }
+
+    /// Get unprocessed part of the path
+    pub fn unprocessed(&self) -> &str {
+        &self.path.path()[(self.skip as usize)..]
+    }
+
+    /// Get matched parameter by name.
+    ///
+    /// If keyed parameter is not available empty string is used as default value.
+    pub fn query(&self, key: &str) -> &str {
+        profile_method!(query);
+
+        if let Some(s) = self.get(key) {
+            s
+        } else {
+            ""
+        }
+    }
+
+    /// Return iterator to items in parameter container.
+    pub fn iter(&self) -> PathIter<'_, T> {
+        PathIter {
+            idx: 0,
+            params: self,
+        }
+    }
+
+    /// Try to deserialize matching parameters to a specified type `U`
+    pub fn load<'de, U: serde::Deserialize<'de>>(&'de self) -> Result<U, de::value::Error> {
+        profile_method!(load);
+        de::Deserialize::deserialize(PathDeserializer::new(self))
+    }
+}
+
+#[derive(Debug)]
+pub struct PathIter<'a, T> {
+    idx: usize,
+    params: &'a Path<T>,
+}
+
+impl<'a, T: ResourcePath> Iterator for PathIter<'a, T> {
+    type Item = (&'a str, &'a str);
+
+    #[inline]
+    fn next(&mut self) -> Option<(&'a str, &'a str)> {
+        if self.idx < self.params.segment_count() {
+            let idx = self.idx;
+            let res = match self.params.segments[idx].1 {
+                PathItem::Static(ref s) => s,
+                PathItem::Segment(s, e) => &self.params.path.path()[(s as usize)..(e as usize)],
+            };
+            self.idx += 1;
+            return Some((&self.params.segments[idx].0, res));
+        }
+        None
+    }
+}
+
+impl<'a, T: ResourcePath> Index<&'a str> for Path<T> {
+    type Output = str;
+
+    fn index(&self, name: &'a str) -> &str {
+        self.get(name)
+            .expect("Value for parameter is not available")
+    }
+}
+
+impl<T: ResourcePath> Index<usize> for Path<T> {
+    type Output = str;
+
+    fn index(&self, idx: usize) -> &str {
+        match self.segments[idx].1 {
+            PathItem::Static(ref s) => s,
+            PathItem::Segment(s, e) => &self.path.path()[(s as usize)..(e as usize)],
+        }
+    }
+}
+
+impl<T: ResourcePath> Resource<T> for Path<T> {
+    fn resource_path(&mut self) -> &mut Self {
+        self
+    }
+}

actix-router/src/router.rs

@@ -0,0 +1,281 @@
+use firestorm::profile_method;
+
+use crate::{IntoPatterns, Resource, ResourceDef, ResourcePath};
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct ResourceId(pub u16);
+
+/// Information about current resource
+#[derive(Clone, Debug)]
+pub struct ResourceInfo {
+    resource: ResourceId,
+}
+
+/// Resource router.
+// T is the resource itself
+// U is any other data needed for routing like method guards
+pub struct Router<T, U = ()> {
+    routes: Vec<(ResourceDef, T, Option<U>)>,
+}
+
+impl<T, U> Router<T, U> {
+    pub fn build() -> RouterBuilder<T, U> {
+        RouterBuilder {
+            resources: Vec::new(),
+        }
+    }
+
+    pub fn recognize<R, P>(&self, resource: &mut R) -> Option<(&T, ResourceId)>
+    where
+        R: Resource<P>,
+        P: ResourcePath,
+    {
+        profile_method!(recognize);
+
+        for item in self.routes.iter() {
+            if item.0.capture_match_info(resource.resource_path()) {
+                return Some((&item.1, ResourceId(item.0.id())));
+            }
+        }
+
+        None
+    }
+
+    pub fn recognize_mut<R, P>(&mut self, resource: &mut R) -> Option<(&mut T, ResourceId)>
+    where
+        R: Resource<P>,
+        P: ResourcePath,
+    {
+        profile_method!(recognize_mut);
+
+        for item in self.routes.iter_mut() {
+            if item.0.capture_match_info(resource.resource_path()) {
+                return Some((&mut item.1, ResourceId(item.0.id())));
+            }
+        }
+
+        None
+    }
+
+    pub fn recognize_fn<R, P, F>(&self, resource: &mut R, check: F) -> Option<(&T, ResourceId)>
+    where
+        F: Fn(&R, &Option<U>) -> bool,
+        R: Resource<P>,
+        P: ResourcePath,
+    {
+        profile_method!(recognize_checked);
+
+        for item in self.routes.iter() {
+            if item.0.capture_match_info_fn(resource, &check, &item.2) {
+                return Some((&item.1, ResourceId(item.0.id())));
+            }
+        }
+
+        None
+    }
+
+    pub fn recognize_mut_fn<R, P, F>(
+        &mut self,
+        resource: &mut R,
+        check: F,
+    ) -> Option<(&mut T, ResourceId)>
+    where
+        F: Fn(&R, &Option<U>) -> bool,
+        R: Resource<P>,
+        P: ResourcePath,
+    {
+        profile_method!(recognize_mut_checked);
+
+        for item in self.routes.iter_mut() {
+            if item.0.capture_match_info_fn(resource, &check, &item.2) {
+                return Some((&mut item.1, ResourceId(item.0.id())));
+            }
+        }
+
+        None
+    }
+}
+
+pub struct RouterBuilder<T, U = ()> {
+    resources: Vec<(ResourceDef, T, Option<U>)>,
+}
+
+impl<T, U> RouterBuilder<T, U> {
+    /// Register resource for specified path.
+    pub fn path<P: IntoPatterns>(
+        &mut self,
+        path: P,
+        resource: T,
+    ) -> &mut (ResourceDef, T, Option<U>) {
+        profile_method!(path);
+
+        self.resources
+            .push((ResourceDef::new(path), resource, None));
+        self.resources.last_mut().unwrap()
+    }
+
+    /// Register resource for specified path prefix.
+    pub fn prefix(&mut self, prefix: &str, resource: T) -> &mut (ResourceDef, T, Option<U>) {
+        profile_method!(prefix);
+
+        self.resources
+            .push((ResourceDef::prefix(prefix), resource, None));
+        self.resources.last_mut().unwrap()
+    }
+
+    /// Register resource for ResourceDef
+    pub fn rdef(&mut self, rdef: ResourceDef, resource: T) -> &mut (ResourceDef, T, Option<U>) {
+        profile_method!(rdef);
+
+        self.resources.push((rdef, resource, None));
+        self.resources.last_mut().unwrap()
+    }
+
+    /// Finish configuration and create router instance.
+    pub fn finish(self) -> Router<T, U> {
+        Router {
+            routes: self.resources,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::path::Path;
+    use crate::router::{ResourceId, Router};
+
+    #[allow(clippy::cognitive_complexity)]
+    #[test]
+    fn test_recognizer_1() {
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10).0.set_id(0);
+        router.path("/name/{val}", 11).0.set_id(1);
+        router.path("/name/{val}/index.html", 12).0.set_id(2);
+        router.path("/file/{file}.{ext}", 13).0.set_id(3);
+        router.path("/v{val}/{val2}/index.html", 14).0.set_id(4);
+        router.path("/v/{tail:.*}", 15).0.set_id(5);
+        router.path("/test2/{test}.html", 16).0.set_id(6);
+        router.path("/{test}/index.html", 17).0.set_id(7);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/unknown");
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/name");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+        assert_eq!(info, ResourceId(0));
+        assert!(path.is_empty());
+
+        let mut path = Path::new("/name/value");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(info, ResourceId(1));
+        assert_eq!(path.get("val").unwrap(), "value");
+        assert_eq!(&path["val"], "value");
+
+        let mut path = Path::new("/name/value2/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 12);
+        assert_eq!(info, ResourceId(2));
+        assert_eq!(path.get("val").unwrap(), "value2");
+
+        let mut path = Path::new("/file/file.gz");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 13);
+        assert_eq!(info, ResourceId(3));
+        assert_eq!(path.get("file").unwrap(), "file");
+        assert_eq!(path.get("ext").unwrap(), "gz");
+
+        let mut path = Path::new("/vtest/ttt/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 14);
+        assert_eq!(info, ResourceId(4));
+        assert_eq!(path.get("val").unwrap(), "test");
+        assert_eq!(path.get("val2").unwrap(), "ttt");
+
+        let mut path = Path::new("/v/blah-blah/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 15);
+        assert_eq!(info, ResourceId(5));
+        assert_eq!(path.get("tail").unwrap(), "blah-blah/index.html");
+
+        let mut path = Path::new("/test2/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 16);
+        assert_eq!(info, ResourceId(6));
+        assert_eq!(path.get("test").unwrap(), "index");
+
+        let mut path = Path::new("/bbb/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 17);
+        assert_eq!(info, ResourceId(7));
+        assert_eq!(path.get("test").unwrap(), "bbb");
+    }
+
+    #[test]
+    fn test_recognizer_2() {
+        let mut router = Router::<usize>::build();
+        router.path("/index.json", 10);
+        router.path("/{source}.json", 11);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/index.json");
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test.json");
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+    }
+
+    #[test]
+    fn test_recognizer_with_prefix() {
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10).0.set_id(0);
+        router.path("/name/{val}", 11).0.set_id(1);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/name");
+        path.skip(5);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test/name");
+        path.skip(5);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test/name/value");
+        path.skip(5);
+        let (h, id) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(id, ResourceId(1));
+        assert_eq!(path.get("val").unwrap(), "value");
+        assert_eq!(&path["val"], "value");
+
+        // same patterns
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10);
+        router.path("/name/{val}", 11);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/name");
+        path.skip(6);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test2/name");
+        path.skip(6);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test2/name-test");
+        path.skip(6);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test2/name/ttt");
+        path.skip(6);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(&path["val"], "ttt");
+    }
+}

actix-router/src/url.rs

@@ -0,0 +1,288 @@
+use crate::ResourcePath;
+
+#[allow(dead_code)]
+const GEN_DELIMS: &[u8] = b":/?#[]@";
+#[allow(dead_code)]
+const SUB_DELIMS_WITHOUT_QS: &[u8] = b"!$'()*,";
+#[allow(dead_code)]
+const SUB_DELIMS: &[u8] = b"!$'()*,+?=;";
+#[allow(dead_code)]
+const RESERVED: &[u8] = b":/?#[]@!$'()*,+?=;";
+#[allow(dead_code)]
+const UNRESERVED: &[u8] = b"abcdefghijklmnopqrstuvwxyz
+    ABCDEFGHIJKLMNOPQRSTUVWXYZ
+    1234567890
+    -._~";
+const ALLOWED: &[u8] = b"abcdefghijklmnopqrstuvwxyz
+    ABCDEFGHIJKLMNOPQRSTUVWXYZ
+    1234567890
+    -._~
+    !$'()*,";
+const QS: &[u8] = b"+&=;b";
+
+#[inline]
+fn bit_at(array: &[u8], ch: u8) -> bool {
+    array[(ch >> 3) as usize] & (1 << (ch & 7)) != 0
+}
+
+#[inline]
+fn set_bit(array: &mut [u8], ch: u8) {
+    array[(ch >> 3) as usize] |= 1 << (ch & 7)
+}
+
+thread_local! {
+    static DEFAULT_QUOTER: Quoter = Quoter::new(b"@:", b"%/+");
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct Url {
+    uri: http::Uri,
+    path: Option<String>,
+}
+
+impl Url {
+    pub fn new(uri: http::Uri) -> Url {
+        let path = DEFAULT_QUOTER.with(|q| q.requote(uri.path().as_bytes()));
+
+        Url { uri, path }
+    }
+
+    pub fn with_quoter(uri: http::Uri, quoter: &Quoter) -> Url {
+        Url {
+            path: quoter.requote(uri.path().as_bytes()),
+            uri,
+        }
+    }
+
+    pub fn uri(&self) -> &http::Uri {
+        &self.uri
+    }
+
+    pub fn path(&self) -> &str {
+        if let Some(ref s) = self.path {
+            s
+        } else {
+            self.uri.path()
+        }
+    }
+
+    #[inline]
+    pub fn update(&mut self, uri: &http::Uri) {
+        self.uri = uri.clone();
+        self.path = DEFAULT_QUOTER.with(|q| q.requote(uri.path().as_bytes()));
+    }
+
+    #[inline]
+    pub fn update_with_quoter(&mut self, uri: &http::Uri, quoter: &Quoter) {
+        self.uri = uri.clone();
+        self.path = quoter.requote(uri.path().as_bytes());
+    }
+}
+
+impl ResourcePath for Url {
+    #[inline]
+    fn path(&self) -> &str {
+        self.path()
+    }
+}
+
+pub struct Quoter {
+    safe_table: [u8; 16],
+    protected_table: [u8; 16],
+}
+
+impl Quoter {
+    pub fn new(safe: &[u8], protected: &[u8]) -> Quoter {
+        let mut q = Quoter {
+            safe_table: [0; 16],
+            protected_table: [0; 16],
+        };
+
+        // prepare safe table
+        for i in 0..128 {
+            if ALLOWED.contains(&i) {
+                set_bit(&mut q.safe_table, i);
+            }
+            if QS.contains(&i) {
+                set_bit(&mut q.safe_table, i);
+            }
+        }
+
+        for ch in safe {
+            set_bit(&mut q.safe_table, *ch)
+        }
+
+        // prepare protected table
+        for ch in protected {
+            set_bit(&mut q.safe_table, *ch);
+            set_bit(&mut q.protected_table, *ch);
+        }
+
+        q
+    }
+
+    pub fn requote(&self, val: &[u8]) -> Option<String> {
+        let mut has_pct = 0;
+        let mut pct = [b'%', 0, 0];
+        let mut idx = 0;
+        let mut cloned: Option<Vec<u8>> = None;
+
+        let len = val.len();
+        while idx < len {
+            let ch = val[idx];
+
+            if has_pct != 0 {
+                pct[has_pct] = val[idx];
+                has_pct += 1;
+                if has_pct == 3 {
+                    has_pct = 0;
+                    let buf = cloned.as_mut().unwrap();
+
+                    if let Some(ch) = restore_ch(pct[1], pct[2]) {
+                        if ch < 128 {
+                            if bit_at(&self.protected_table, ch) {
+                                buf.extend_from_slice(&pct);
+                                idx += 1;
+                                continue;
+                            }
+
+                            if bit_at(&self.safe_table, ch) {
+                                buf.push(ch);
+                                idx += 1;
+                                continue;
+                            }
+                        }
+                        buf.push(ch);
+                    } else {
+                        buf.extend_from_slice(&pct[..]);
+                    }
+                }
+            } else if ch == b'%' {
+                has_pct = 1;
+                if cloned.is_none() {
+                    let mut c = Vec::with_capacity(len);
+                    c.extend_from_slice(&val[..idx]);
+                    cloned = Some(c);
+                }
+            } else if let Some(ref mut cloned) = cloned {
+                cloned.push(ch)
+            }
+            idx += 1;
+        }
+
+        cloned.map(|data| String::from_utf8_lossy(&data).into_owned())
+    }
+}
+
+#[inline]
+fn from_hex(v: u8) -> Option<u8> {
+    if (b'0'..=b'9').contains(&v) {
+        Some(v - 0x30) // ord('0') == 0x30
+    } else if (b'A'..=b'F').contains(&v) {
+        Some(v - 0x41 + 10) // ord('A') == 0x41
+    } else if (b'a'..=b'f').contains(&v) {
+        Some(v - 0x61 + 10) // ord('a') == 0x61
+    } else {
+        None
+    }
+}
+
+#[inline]
+fn restore_ch(d1: u8, d2: u8) -> Option<u8> {
+    from_hex(d1).and_then(|d1| from_hex(d2).map(move |d2| d1 << 4 | d2))
+}
+
+#[cfg(test)]
+mod tests {
+    use http::Uri;
+    use std::convert::TryFrom;
+
+    use super::*;
+    use crate::{Path, ResourceDef};
+
+    const PROTECTED: &[u8] = b"%/+";
+
+    fn match_url(pattern: &'static str, url: impl AsRef<str>) -> Path<Url> {
+        let re = ResourceDef::new(pattern);
+        let uri = Uri::try_from(url.as_ref()).unwrap();
+        let mut path = Path::new(Url::new(uri));
+        assert!(re.capture_match_info(&mut path));
+        path
+    }
+
+    fn percent_encode(data: &[u8]) -> String {
+        data.iter().map(|c| format!("%{:02X}", c)).collect()
+    }
+
+    #[test]
+    fn test_parse_url() {
+        let re = "/user/{id}/test";
+
+        let path = match_url(re, "/user/2345/test");
+        assert_eq!(path.get("id").unwrap(), "2345");
+
+        // "%25" should never be decoded into '%' to guarantee the output is a valid
+        // percent-encoded format
+        let path = match_url(re, "/user/qwe%25/test");
+        assert_eq!(path.get("id").unwrap(), "qwe%25");
+
+        let path = match_url(re, "/user/qwe%25rty/test");
+        assert_eq!(path.get("id").unwrap(), "qwe%25rty");
+    }
+
+    #[test]
+    fn test_protected_chars() {
+        let encoded = percent_encode(PROTECTED);
+        let path = match_url("/user/{id}/test", format!("/user/{}/test", encoded));
+        assert_eq!(path.get("id").unwrap(), &encoded);
+    }
+
+    #[test]
+    fn test_non_protecteed_ascii() {
+        let nonprotected_ascii = ('\u{0}'..='\u{7F}')
+            .filter(|&c| c.is_ascii() && !PROTECTED.contains(&(c as u8)))
+            .collect::<String>();
+        let encoded = percent_encode(nonprotected_ascii.as_bytes());
+        let path = match_url("/user/{id}/test", format!("/user/{}/test", encoded));
+        assert_eq!(path.get("id").unwrap(), &nonprotected_ascii);
+    }
+
+    #[test]
+    fn test_valid_utf8_multibyte() {
+        let test = ('\u{FF00}'..='\u{FFFF}').collect::<String>();
+        let encoded = percent_encode(test.as_bytes());
+        let path = match_url("/a/{id}/b", format!("/a/{}/b", &encoded));
+        assert_eq!(path.get("id").unwrap(), &test);
+    }
+
+    #[test]
+    fn test_invalid_utf8() {
+        let invalid_utf8 = percent_encode((0x80..=0xff).collect::<Vec<_>>().as_slice());
+        let uri = Uri::try_from(format!("/{}", invalid_utf8)).unwrap();
+        let path = Path::new(Url::new(uri));
+
+        // We should always get a valid utf8 string
+        assert!(String::from_utf8(path.path().as_bytes().to_owned()).is_ok());
+    }
+
+    #[test]
+    fn test_from_hex() {
+        let hex = b"0123456789abcdefABCDEF";
+
+        for i in 0..256 {
+            let c = i as u8;
+            if hex.contains(&c) {
+                assert!(from_hex(c).is_some())
+            } else {
+                assert!(from_hex(c).is_none())
+            }
+        }
+
+        let expected = [
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15,
+        ];
+        for i in 0..hex.len() {
+            assert_eq!(from_hex(hex[i]).unwrap(), expected[i]);
+        }
+    }
+}

actix-test/CHANGES.md

@@ -1,6 +1,7 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+* Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 0.1.0-beta.3 - 2021-06-20

actix-web-actors/CHANGES.md

@@ -1,6 +1,7 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+* Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 4.0.0-beta.6 - 2021-06-26

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.0.0-beta.6)](https://docs.rs/actix-web-actors/4.0.0-beta.6)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Version](https://img.shields.io/badge/rustc-1.51+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.51.html)
 ![License](https://img.shields.io/crates/l/actix-web-actors.svg)
 <br />
 [![dependency status](https://deps.rs/crate/actix-web-actors/4.0.0-beta.6/status.svg)](https://deps.rs/crate/actix-web-actors/4.0.0-beta.6)
@@ -14,4 +14,4 @@
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-web-actors)
-- Minimum supported Rust version: 1.46 or later
+- Minimum supported Rust version: 1.51 or later

actix-web-codegen/CHANGES.md

@@ -1,6 +1,10 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+* In routing macros, paths are now validated at compile time. [#2350]
+* Minimum supported Rust version (MSRV) is now 1.51.
+
+[#2350]: https://github.com/actix/actix-web/pull/2350
 
 
 ## 0.5.0-beta.3 - 2021-06-17

actix-web-codegen/Cargo.toml

@@ -17,6 +17,7 @@ proc-macro = true
 quote = "1"
 syn = { version = "1", features = ["full", "parsing"] }
 proc-macro2 = "1"
+actix-router = "0.5.0-beta.1"
 
 [dev-dependencies]
 actix-rt = "2.2"

actix-web-codegen/README.md

@@ -4,7 +4,7 @@
 
 [![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=0.5.0-beta.3)](https://docs.rs/actix-web-codegen/0.5.0-beta.3)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+[![Version](https://img.shields.io/badge/rustc-1.51+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.51.html)
 ![License](https://img.shields.io/crates/l/actix-web-codegen.svg)
 <br />
 [![dependency status](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.3/status.svg)](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.3)
@@ -14,7 +14,7 @@
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-web-codegen)
-- Minimum supported Rust version: 1.46 or later.
+- Minimum supported Rust version: 1.51 or later.
 
 ## Compile Testing
 

actix-web-codegen/src/route.rs

@@ -3,6 +3,7 @@ extern crate proc_macro;
 use std::collections::HashSet;
 use std::convert::TryFrom;
 
+use actix_router::ResourceDef;
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{format_ident, quote, ToTokens, TokenStreamExt};
@@ -101,6 +102,7 @@ impl Args {
             match arg {
                 NestedMeta::Lit(syn::Lit::Str(lit)) => match path {
                     None => {
+                        let _ = ResourceDef::new(lit.value());
                         path = Some(lit);
                     }
                     _ => {

actix-web-codegen/tests/trybuild.rs

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

actix-web-codegen/tests/trybuild/route-malformed-path-fail.rs

@@ -0,0 +1,33 @@
+use actix_web_codegen::get;
+
+#[get("/{")]
+async fn zero() -> &'static str {
+    "malformed resource def"
+}
+
+#[get("/{foo")]
+async fn one() -> &'static str {
+    "malformed resource def"
+}
+
+#[get("/{}")]
+async fn two() -> &'static str {
+    "malformed resource def"
+}
+
+#[get("/*")]
+async fn three() -> &'static str {
+    "malformed resource def"
+}
+
+#[get("/{tail:\\d+}*")]
+async fn four() -> &'static str {
+    "malformed resource def"
+}
+
+#[get("/{a}/{b}/{c}/{d}/{e}/{f}/{g}/{h}/{i}/{j}/{k}/{l}/{m}/{n}/{o}/{p}/{q}")]
+async fn five() -> &'static str {
+    "malformed resource def"
+}
+
+fn main() {}

actix-web-codegen/tests/trybuild/route-malformed-path-fail.stderr

@@ -0,0 +1,42 @@
+error: custom attribute panicked
+ --> $DIR/route-malformed-path-fail.rs:3:1
+  |
+3 | #[get("/{")]
+  | ^^^^^^^^^^^^
+  |
+  = help: message: pattern "{" contains malformed dynamic segment
+
+error: custom attribute panicked
+ --> $DIR/route-malformed-path-fail.rs:8:1
+  |
+8 | #[get("/{foo")]
+  | ^^^^^^^^^^^^^^^
+  |
+  = help: message: pattern "{foo" contains malformed dynamic segment
+
+error: custom attribute panicked
+  --> $DIR/route-malformed-path-fail.rs:13:1
+   |
+13 | #[get("/{}")]
+   | ^^^^^^^^^^^^^
+   |
+   = help: message: Wrong path pattern: "/{}" regex parse error:
+               ((?s-m)^/(?P<>[^/]+))$
+                            ^
+           error: empty capture group name
+
+error: custom attribute panicked
+  --> $DIR/route-malformed-path-fail.rs:23:1
+   |
+23 | #[get("/{tail:\\d+}*")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: message: custom regex is not supported for tail match
+
+error: custom attribute panicked
+  --> $DIR/route-malformed-path-fail.rs:28:1
+   |
+28 | #[get("/{a}/{b}/{c}/{d}/{e}/{f}/{g}/{h}/{i}/{j}/{k}/{l}/{m}/{n}/{o}/{p}/{q}")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: message: Only 16 dynamic segments are allowed, provided: 17

awc/README.md

@@ -12,7 +12,7 @@
 
 - [API Documentation](https://docs.rs/awc)
 - [Example Project](https://github.com/actix/examples/tree/HEAD/security/awc_https)
-- Minimum Supported Rust Version (MSRV): 1.46.0
+- Minimum Supported Rust Version (MSRV): 1.51.0
 
 ## Example
 

clippy.toml

@@ -1 +1 @@
-msrv = "1.46"
+msrv = "1.51"

docs/graphs/net-only.dot

@@ -4,7 +4,7 @@ digraph {
     subgraph cluster_net {
         label="actix-net"
         "actix-codec" "actix-macros" "actix-rt" "actix-server" "actix-service"
-        "actix-tls" "actix-tracing" "actix-utils" "actix-router"
+        "actix-tls" "actix-tracing" "actix-utils"
     }
     
     subgraph cluster_other {
@@ -25,7 +25,6 @@ digraph {
     "actix-tls" -> { "tokio-util" }[color="#009900"]
     "actix-server" -> { "actix-service" "actix-rt" "actix-utils" "tokio" }
     "actix-rt" -> { "actix-macros" "tokio" }
-    "actix-router" -> { "bytestring" }
 
     "local-channel" -> { "local-waker" }
 

docs/graphs/web-focus.dot

@@ -10,6 +10,7 @@ digraph {
         "web-actors"
         "web-codegen"
         "http-test"
+        "router"
 
         { rank=same; "multipart" "web-actors" "http-test" };
         { rank=same; "files" "awc" "web" };
@@ -36,7 +37,7 @@ digraph {
     "rt" -> { "macros" }
 
     { rank=same; "utils" "codec" };
-    { rank=same; "rt" "macros" "service" "router" };
+    { rank=same; "rt" "macros" "service" };
 
     // actix
 

docs/graphs/web-only.dot

@@ -10,9 +10,10 @@ digraph {
         "actix-web-codegen"
         "actix-http-test"
         "actix-test"
+        "actix-router"
     }
 
-    "actix-web" -> { "actix-web-codegen" "actix-http" }
+    "actix-web" -> { "actix-web-codegen" "actix-http" "actix-router" }
     "awc" -> { "actix-http" }
     "actix-web-actors" -> { "actix" "actix-web" "actix-http" }
     "actix-multipart" -> { "actix-web" }

src/app.rs

@@ -334,7 +334,7 @@ where
         U: AsRef<str>,
     {
         let mut rdef = ResourceDef::new(url.as_ref());
-        *rdef.name_mut() = name.as_ref().to_string();
+        rdef.set_name(name.as_ref());
         self.external.push(rdef);
         self
     }

src/app_service.rs

@@ -291,7 +291,7 @@ impl Service<ServiceRequest> for AppRouting {
     actix_service::always_ready!();
 
     fn call(&self, mut req: ServiceRequest) -> Self::Future {
-        let res = self.router.recognize_checked(&mut req, |req, guards| {
+        let res = self.router.recognize_fn(&mut req, |req, guards| {
             if let Some(ref guards) = guards {
                 for f in guards {
                     if !f.check(req.head()) {

src/config.rs

@@ -249,7 +249,7 @@ impl ServiceConfig {
         U: AsRef<str>,
     {
         let mut rdef = ResourceDef::new(url.as_ref());
-        *rdef.name_mut() = name.as_ref().to_string();
+        rdef.set_name(name.as_ref());
         self.external.push(rdef);
         self
     }

src/dev.rs

@@ -28,11 +28,22 @@ pub use actix_service::{
 use crate::http::header::ContentEncoding;
 use actix_http::{Response, ResponseBuilder};
 
-pub(crate) fn insert_leading_slash(mut patterns: Vec<String>) -> Vec<String> {
+use actix_router::Patterns;
-    for path in &mut patterns {
+
-        if !path.is_empty() && !path.starts_with('/') {
+pub(crate) fn ensure_leading_slash(mut patterns: Patterns) -> Patterns {
-            path.insert(0, '/');
+    match &mut patterns {
-        };
+        Patterns::Single(pat) => {
+            if !pat.is_empty() && !pat.starts_with('/') {
+                pat.insert(0, '/');
+            };
+        }
+        Patterns::List(pats) => {
+            for pat in pats {
+                if !pat.is_empty() && !pat.starts_with('/') {
+                    pat.insert(0, '/');
+                };
+            }
+        }
     }
 
     patterns

src/http/header/content_disposition.rs

@@ -457,7 +457,7 @@ impl Header for ContentDisposition {
 
     fn parse<T: crate::HttpMessage>(msg: &T) -> Result<Self, crate::error::ParseError> {
         if let Some(h) = msg.headers().get(&Self::name()) {
-            Self::from_raw(&h)
+            Self::from_raw(h)
         } else {
             Err(crate::error::ParseError::Header)
         }

src/lib.rs

@@ -53,7 +53,7 @@
 //! * SSL support using OpenSSL or Rustls
 //! * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
 //! * Includes an async [HTTP client](https://docs.rs/awc/)
-//! * Runs on stable Rust 1.46+
+//! * Runs on stable Rust 1.51+
 //!
 //! # Crate Features
 //! * `cookies` - cookies support (enabled by default)

src/middleware/logger.rs

@@ -341,7 +341,6 @@ where
     ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         let this = self.project();
 
-        // TODO: MSRV 1.51: poll_map_err
         match ready!(this.body.poll_next(cx)) {
             Some(Ok(chunk)) => {
                 *this.size += chunk.len();
@@ -553,7 +552,7 @@ impl FormatText {
                 *self = FormatText::Str(s.to_string());
             }
             FormatText::RemoteAddr => {
-                let s = if let Some(ref peer) = req.connection_info().remote_addr() {
+                let s = if let Some(peer) = req.connection_info().remote_addr() {
                     FormatText::Str((*peer).to_string())
                 } else {
                     FormatText::Str("-".to_string())

src/middleware/mod.rs

@@ -19,3 +19,43 @@ mod compress;
 
 #[cfg(feature = "__compress")]
 pub use self::compress::Compress;
+
+#[cfg(test)]
+mod tests {
+    use crate::{http::StatusCode, App};
+
+    use super::*;
+
+    #[test]
+    fn common_combinations() {
+        // ensure there's no reason that the built-in middleware cannot compose
+
+        let _ = App::new()
+            .wrap(Compat::new(Logger::default()))
+            .wrap(Condition::new(true, DefaultHeaders::new()))
+            .wrap(DefaultHeaders::new().header("X-Test2", "X-Value2"))
+            .wrap(ErrorHandlers::new().handler(StatusCode::FORBIDDEN, |res| {
+                Ok(ErrorHandlerResponse::Response(res))
+            }))
+            .wrap(Logger::default())
+            .wrap(NormalizePath::new(TrailingSlash::Trim));
+
+        let _ = App::new()
+            .wrap(NormalizePath::new(TrailingSlash::Trim))
+            .wrap(Logger::default())
+            .wrap(ErrorHandlers::new().handler(StatusCode::FORBIDDEN, |res| {
+                Ok(ErrorHandlerResponse::Response(res))
+            }))
+            .wrap(DefaultHeaders::new().header("X-Test2", "X-Value2"))
+            .wrap(Condition::new(true, DefaultHeaders::new()))
+            .wrap(Compat::new(Logger::default()));
+
+        #[cfg(feature = "__compress")]
+        {
+            let _ = App::new().wrap(Compress::default()).wrap(Logger::default());
+            let _ = App::new().wrap(Logger::default()).wrap(Compress::default());
+            let _ = App::new().wrap(Compat::new(Compress::default()));
+            let _ = App::new().wrap(Condition::new(true, Compat::new(Compress::default())));
+        }
+    }
+}

src/middleware/normalize.rs

@@ -59,7 +59,7 @@ impl Default for TrailingSlash {
 ///
 /// # actix_web::rt::System::new().block_on(async {
 /// let app = App::new()
-///     .wrap(middleware::NormalizePath::default())
+///     .wrap(middleware::NormalizePath::trim())
 ///     .route("/test", web::get().to(|| async { "test" }))
 ///     .route("/unmatchable/", web::get().to(|| async { "unmatchable" }));
 ///
@@ -85,13 +85,31 @@ impl Default for TrailingSlash {
 /// assert_eq!(res.status(), StatusCode::NOT_FOUND);
 /// # })
 /// ```
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy)]
 pub struct NormalizePath(TrailingSlash);
 
+impl Default for NormalizePath {
+    fn default() -> Self {
+        log::warn!(
+            "`NormalizePath::default()` is deprecated. The default trailing slash behavior changed \
+            in v4 from `Always` to `Trim`. Update your call to `NormalizePath::new(...)`."
+        );
+
+        Self(TrailingSlash::Trim)
+    }
+}
+
 impl NormalizePath {
     /// Create new `NormalizePath` middleware with the specified trailing slash style.
     pub fn new(trailing_slash_style: TrailingSlash) -> Self {
-        NormalizePath(trailing_slash_style)
+        Self(trailing_slash_style)
+    }
+
+    /// Constructs a new `NormalizePath` middleware with [trim](TrailingSlash::Trim) semantics.
+    ///
+    /// Use this instead of `NormalizePath::default()` to avoid deprecation warning.
+    pub fn trim() -> Self {
+        Self::new(TrailingSlash::Trim)
     }
 }
 

src/request.rs

@@ -184,7 +184,7 @@ impl HttpRequest {
         U: IntoIterator<Item = I>,
         I: AsRef<str>,
     {
-        self.resource_map().url_for(&self, name, elements)
+        self.resource_map().url_for(self, name, elements)
     }
 
     /// Generate url for named resource
@@ -199,7 +199,7 @@ impl HttpRequest {
     #[inline]
     /// Get a reference to a `ResourceMap` of current application.
     pub fn resource_map(&self) -> &ResourceMap {
-        &self.app_state().rmap()
+        self.app_state().rmap()
     }
 
     /// Peer socket address.
@@ -509,7 +509,7 @@ mod tests {
     #[test]
     fn test_url_for() {
         let mut res = ResourceDef::new("/user/{name}.{ext}");
-        *res.name_mut() = "index".to_string();
+        res.set_name("index");
 
         let mut rmap = ResourceMap::new(ResourceDef::new(""));
         rmap.add(&mut res, None);
@@ -539,7 +539,7 @@ mod tests {
     #[test]
     fn test_url_for_static() {
         let mut rdef = ResourceDef::new("/index.html");
-        *rdef.name_mut() = "index".to_string();
+        rdef.set_name("index");
 
         let mut rmap = ResourceMap::new(ResourceDef::new(""));
         rmap.add(&mut rdef, None);
@@ -560,7 +560,7 @@ mod tests {
     #[test]
     fn test_match_name() {
         let mut rdef = ResourceDef::new("/index.html");
-        *rdef.name_mut() = "index".to_string();
+        rdef.set_name("index");
 
         let mut rmap = ResourceMap::new(ResourceDef::new(""));
         rmap.add(&mut rdef, None);
@@ -579,7 +579,7 @@ mod tests {
     fn test_url_for_external() {
         let mut rdef = ResourceDef::new("https://youtube.com/watch/{video_id}");
 
-        *rdef.name_mut() = "youtube".to_string();
+        rdef.set_name("youtube");
 
         let mut rmap = ResourceMap::new(ResourceDef::new(""));
         rmap.add(&mut rdef, None);

src/resource.rs

@@ -4,7 +4,7 @@ use std::future::Future;
 use std::rc::Rc;
 
 use actix_http::Extensions;
-use actix_router::IntoPattern;
+use actix_router::{IntoPatterns, Patterns};
 use actix_service::boxed::{self, BoxService, BoxServiceFactory};
 use actix_service::{
     apply, apply_fn_factory, fn_service, IntoServiceFactory, Service, ServiceFactory,
@@ -15,7 +15,7 @@ use futures_util::future::join_all;
 
 use crate::{
     data::Data,
-    dev::{insert_leading_slash, AppService, HttpServiceFactory, ResourceDef},
+    dev::{ensure_leading_slash, AppService, HttpServiceFactory, ResourceDef},
     guard::Guard,
     handler::Handler,
     responder::Responder,
@@ -51,7 +51,7 @@ type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Err
 /// Default behavior could be overridden with `default_resource()` method.
 pub struct Resource<T = ResourceEndpoint> {
     endpoint: T,
-    rdef: Vec<String>,
+    rdef: Patterns,
     name: Option<String>,
     routes: Vec<Route>,
     app_data: Option<Extensions>,
@@ -61,7 +61,7 @@ pub struct Resource<T = ResourceEndpoint> {
 }
 
 impl Resource {
-    pub fn new<T: IntoPattern>(path: T) -> Resource {
+    pub fn new<T: IntoPatterns>(path: T) -> Resource {
         let fref = Rc::new(RefCell::new(None));
 
         Resource {
@@ -391,13 +391,13 @@ where
         };
 
         let mut rdef = if config.is_root() || !self.rdef.is_empty() {
-            ResourceDef::new(insert_leading_slash(self.rdef.clone()))
+            ResourceDef::new(ensure_leading_slash(self.rdef.clone()))
         } else {
             ResourceDef::new(self.rdef.clone())
         };
 
         if let Some(ref name) = self.name {
-            *rdef.name_mut() = name.clone();
+            rdef.set_name(name);
         }
 
         *self.factory_ref.borrow_mut() = Some(ResourceFactory {

src/responder.rs

@@ -270,7 +270,7 @@ pub(crate) mod tests {
     impl BodyTest for Body {
         fn bin_ref(&self) -> &[u8] {
             match self {
-                Body::Bytes(ref bin) => &bin,
+                Body::Bytes(ref bin) => bin,
                 _ => unreachable!("bug in test impl"),
             }
         }
@@ -283,11 +283,11 @@ pub(crate) mod tests {
         fn bin_ref(&self) -> &[u8] {
             match self {
                 ResponseBody::Body(ref b) => match b {
-                    Body::Bytes(ref bin) => &bin,
+                    Body::Bytes(ref bin) => bin,
                     _ => unreachable!("bug in test impl"),
                 },
                 ResponseBody::Other(ref b) => match b {
-                    Body::Bytes(ref bin) => &bin,
+                    Body::Bytes(ref bin) => bin,
                     _ => unreachable!("bug in test impl"),
                 },
             }

src/rmap.rs

@@ -29,9 +29,8 @@ impl ResourceMap {
     pub fn add(&mut self, pattern: &mut ResourceDef, nested: Option<Rc<ResourceMap>>) {
         pattern.set_id(self.patterns.len() as u16);
         self.patterns.push((pattern.clone(), nested));
-        if !pattern.name().is_empty() {
+        if let Some(name) = pattern.name() {
-            self.named
+            self.named.insert(name.to_owned(), pattern.clone());
-                .insert(pattern.name().to_string(), pattern.clone());
         }
     }
 
@@ -83,10 +82,10 @@ impl ResourceMap {
 
         for (pattern, rmap) in &self.patterns {
             if let Some(ref rmap) = rmap {
-                if let Some(plen) = pattern.is_prefix_match(path) {
+                if let Some(pat_len) = pattern.find_match(path) {
-                    return rmap.has_resource(&path[plen..]);
+                    return rmap.has_resource(&path[pat_len..]);
                 }
-            } else if pattern.is_match(path) || pattern.pattern() == "" && path == "/" {
+            } else if pattern.is_match(path) || pattern.pattern() == Some("") && path == "/" {
                 return true;
             }
         }
@@ -100,14 +99,11 @@ impl ResourceMap {
 
         for (pattern, rmap) in &self.patterns {
             if let Some(ref rmap) = rmap {
-                if let Some(plen) = pattern.is_prefix_match(path) {
+                if let Some(plen) = pattern.find_match(path) {
                     return rmap.match_name(&path[plen..]);
                 }
             } else if pattern.is_match(path) {
-                return match pattern.name() {
+                return pattern.name();
-                    "" => None,
-                    s => Some(s),
-                };
             }
         }
 
@@ -136,8 +132,9 @@ impl ResourceMap {
     fn traverse_resource_pattern(&self, remaining: &str) -> String {
         for (pattern, rmap) in &self.patterns {
             if let Some(ref rmap) = rmap {
-                if let Some(prefix_len) = pattern.is_prefix_match(remaining) {
+                if let Some(prefix_len) = pattern.find_match(remaining) {
-                    let prefix = pattern.pattern().to_owned();
+                    // TODO: think about unwrap_or
+                    let prefix = pattern.pattern().unwrap_or("").to_owned();
 
                     return [
                         prefix,
@@ -146,7 +143,8 @@ impl ResourceMap {
                     .concat();
                 }
             } else if pattern.is_match(remaining) {
-                return pattern.pattern().to_owned();
+                // TODO: think about unwrap_or
+                return pattern.pattern().unwrap_or("").to_owned();
             }
         }
 
@@ -181,10 +179,15 @@ impl ResourceMap {
         I: AsRef<str>,
     {
         if let Some(pattern) = self.named.get(name) {
-            if pattern.pattern().starts_with('/') {
+            if pattern
+                .pattern()
+                .map(|pat| pat.starts_with('/'))
+                .unwrap_or(false)
+            {
                 self.fill_root(path, elements)?;
             }
-            if pattern.resource_path(path, elements) {
+
+            if pattern.resource_path_from_iter(path, elements) {
                 Ok(Some(()))
             } else {
                 Err(UrlGenerationError::NotEnoughElements)
@@ -213,7 +216,8 @@ impl ResourceMap {
         if let Some(ref parent) = self.parent.borrow().upgrade() {
             parent.fill_root(path, elements)?;
         }
-        if self.root.resource_path(path, elements) {
+
+        if self.root.resource_path_from_iter(path, elements) {
             Ok(())
         } else {
             Err(UrlGenerationError::NotEnoughElements)
@@ -233,7 +237,7 @@ impl ResourceMap {
         if let Some(ref parent) = self.parent.borrow().upgrade() {
             if let Some(pattern) = parent.named.get(name) {
                 self.fill_root(path, elements)?;
-                if pattern.resource_path(path, elements) {
+                if pattern.resource_path_from_iter(path, elements) {
                     Ok(Some(()))
                 } else {
                     Err(UrlGenerationError::NotEnoughElements)
@@ -329,7 +333,7 @@ mod tests {
         let mut root = ResourceMap::new(ResourceDef::root_prefix(""));
 
         let mut rdef = ResourceDef::new("/info");
-        *rdef.name_mut() = "root_info".to_owned();
+        rdef.set_name("root_info");
         root.add(&mut rdef, None);
 
         let mut user_map = ResourceMap::new(ResourceDef::root_prefix(""));
@@ -337,7 +341,7 @@ mod tests {
         user_map.add(&mut rdef, None);
 
         let mut rdef = ResourceDef::new("/post/{post_id}");
-        *rdef.name_mut() = "user_post".to_owned();
+        rdef.set_name("user_post");
         user_map.add(&mut rdef, None);
 
         root.add(

src/scope.rs

@@ -530,7 +530,7 @@ impl Service<ServiceRequest> for ScopeService {
     actix_service::always_ready!();
 
     fn call(&self, mut req: ServiceRequest) -> Self::Future {
-        let res = self.router.recognize_checked(&mut req, |req, guards| {
+        let res = self.router.recognize_fn(&mut req, |req, guards| {
             if let Some(ref guards) = guards {
                 for f in guards {
                     if !f.check(req.head()) {
@@ -1153,4 +1153,70 @@ mod tests {
             Bytes::from_static(b"http://localhost:8080/a/b/c/12345")
         );
     }
+
+    #[actix_rt::test]
+    async fn dynamic_scopes() {
+        let srv = init_service(
+            App::new().service(
+                web::scope("/{a}/").service(
+                    web::scope("/{b}/")
+                        .route("", web::get().to(|_: HttpRequest| HttpResponse::Created()))
+                        .route(
+                            "/",
+                            web::get().to(|_: HttpRequest| HttpResponse::Accepted()),
+                        )
+                        .route("/{c}", web::get().to(|_: HttpRequest| HttpResponse::Ok())),
+                ),
+            ),
+        )
+        .await;
+
+        // note the unintuitive behavior with trailing slashes on scopes with dynamic segments
+        let req = TestRequest::with_uri("/a//b//c").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/a//b/").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::CREATED);
+
+        let req = TestRequest::with_uri("/a//b//").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::ACCEPTED);
+
+        let req = TestRequest::with_uri("/a//b//c/d").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+
+        let srv = init_service(
+            App::new().service(
+                web::scope("/{a}").service(
+                    web::scope("/{b}")
+                        .route("", web::get().to(|_: HttpRequest| HttpResponse::Created()))
+                        .route(
+                            "/",
+                            web::get().to(|_: HttpRequest| HttpResponse::Accepted()),
+                        )
+                        .route("/{c}", web::get().to(|_: HttpRequest| HttpResponse::Ok())),
+                ),
+            ),
+        )
+        .await;
+
+        let req = TestRequest::with_uri("/a/b/c").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/a/b").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::CREATED);
+
+        let req = TestRequest::with_uri("/a/b/").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::ACCEPTED);
+
+        let req = TestRequest::with_uri("/a/b/c/d").to_request();
+        let resp = call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    }
 }

src/service.rs

@@ -7,14 +7,14 @@ use actix_http::{
     http::{HeaderMap, Method, StatusCode, Uri, Version},
     Extensions, HttpMessage, Payload, PayloadStream, RequestHead, Response, ResponseHead,
 };
-use actix_router::{IntoPattern, Path, Resource, ResourceDef, Url};
+use actix_router::{IntoPatterns, Path, Patterns, Resource, ResourceDef, Url};
 use actix_service::{IntoServiceFactory, ServiceFactory};
 #[cfg(feature = "cookies")]
 use cookie::{Cookie, ParseError as CookieParseError};
 
 use crate::{
     config::{AppConfig, AppService},
-    dev::insert_leading_slash,
+    dev::ensure_leading_slash,
     guard::Guard,
     info::ConnectionInfo,
     rmap::ResourceMap,
@@ -117,7 +117,7 @@ impl ServiceRequest {
     /// This method returns reference to the request head
     #[inline]
     pub fn head(&self) -> &RequestHead {
-        &self.req.head()
+        self.req.head()
     }
 
     /// This method returns reference to the request head
@@ -212,14 +212,14 @@ impl ServiceRequest {
         self.req.match_pattern()
     }
 
-    #[inline]
     /// Get a mutable reference to the Path parameters.
+    #[inline]
     pub fn match_info_mut(&mut self) -> &mut Path<Url> {
         self.req.match_info_mut()
     }
 
-    #[inline]
     /// Get a reference to a `ResourceMap` of current application.
+    #[inline]
     pub fn resource_map(&self) -> &ResourceMap {
         self.req.resource_map()
     }
@@ -459,14 +459,14 @@ where
 }
 
 pub struct WebService {
-    rdef: Vec<String>,
+    rdef: Patterns,
     name: Option<String>,
     guards: Vec<Box<dyn Guard>>,
 }
 
 impl WebService {
     /// Create new `WebService` instance.
-    pub fn new<T: IntoPattern>(path: T) -> Self {
+    pub fn new<T: IntoPatterns>(path: T) -> Self {
         WebService {
             rdef: path.patterns(),
             name: None,
@@ -528,7 +528,7 @@ impl WebService {
 
 struct WebServiceImpl<T> {
     srv: T,
-    rdef: Vec<String>,
+    rdef: Patterns,
     name: Option<String>,
     guards: Vec<Box<dyn Guard>>,
 }
@@ -551,13 +551,15 @@ where
         };
 
         let mut rdef = if config.is_root() || !self.rdef.is_empty() {
-            ResourceDef::new(insert_leading_slash(self.rdef))
+            ResourceDef::new(ensure_leading_slash(self.rdef))
         } else {
             ResourceDef::new(self.rdef)
         };
+
         if let Some(ref name) = self.name {
-            *rdef.name_mut() = name.clone();
+            rdef.set_name(name);
         }
+
         config.register_service(rdef, guards, self.srv, None)
     }
 }

src/types/either.rs

@@ -253,7 +253,7 @@ where
                         Ok(bytes) => {
                             let fallback = bytes.clone();
                             let left =
-                                L::from_request(&this.req, &mut payload_from_bytes(bytes));
+                                L::from_request(this.req, &mut payload_from_bytes(bytes));
                             EitherExtractState::Left { left, fallback }
                         }
                         Err(err) => break Err(EitherExtractError::Bytes(err)),
@@ -265,7 +265,7 @@ where
                         Ok(extracted) => break Ok(Either::Left(extracted)),
                         Err(left_err) => {
                             let right = R::from_request(
-                                &this.req,
+                                this.req,
                                 &mut payload_from_bytes(mem::take(fallback)),
                             );
                             EitherExtractState::Right {

src/types/json.rs

@@ -425,7 +425,7 @@ where
                         }
                     }
                     None => {
-                        let json = serde_json::from_slice::<T>(&buf)
+                        let json = serde_json::from_slice::<T>(buf)
                             .map_err(JsonPayloadError::Deserialize)?;
                         return Poll::Ready(Ok(json));
                     }

src/types/path.rs

@@ -209,7 +209,7 @@ mod tests {
         let resource = ResourceDef::new("/{value}/");
 
         let mut req = TestRequest::with_uri("/32/").to_srv_request();
-        resource.match_path(req.match_info_mut());
+        resource.capture_match_info(req.match_info_mut());
 
         let (req, mut pl) = req.into_parts();
         assert_eq!(*Path::<i8>::from_request(&req, &mut pl).await.unwrap(), 32);
@@ -221,7 +221,7 @@ mod tests {
         let resource = ResourceDef::new("/{key}/{value}/");
 
         let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
-        resource.match_path(req.match_info_mut());
+        resource.capture_match_info(req.match_info_mut());
 
         let (req, mut pl) = req.into_parts();
         let (Path(res),) = <(Path<(String, String)>,)>::from_request(&req, &mut pl)
@@ -247,7 +247,7 @@ mod tests {
         let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
 
         let resource = ResourceDef::new("/{key}/{value}/");
-        resource.match_path(req.match_info_mut());
+        resource.capture_match_info(req.match_info_mut());
 
         let (req, mut pl) = req.into_parts();
         let mut s = Path::<MyStruct>::from_request(&req, &mut pl).await.unwrap();
@@ -270,7 +270,7 @@ mod tests {
 
         let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
         let resource = ResourceDef::new("/{key}/{value}/");
-        resource.match_path(req.match_info_mut());
+        resource.capture_match_info(req.match_info_mut());
 
         let (req, mut pl) = req.into_parts();
         let s = Path::<Test2>::from_request(&req, &mut pl).await.unwrap();

src/types/query.rs

@@ -213,10 +213,10 @@ mod tests {
     #[actix_rt::test]
     async fn test_service_request_extract() {
         let req = TestRequest::with_uri("/name/user1/").to_srv_request();
-        assert!(Query::<Id>::from_query(&req.query_string()).is_err());
+        assert!(Query::<Id>::from_query(req.query_string()).is_err());
 
         let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
-        let mut s = Query::<Id>::from_query(&req.query_string()).unwrap();
+        let mut s = Query::<Id>::from_query(req.query_string()).unwrap();
 
         assert_eq!(s.id, "test");
         assert_eq!(

src/web.rs

@@ -1,10 +1,10 @@
 //! Essentials helper functions and types for application registration.
 
-use actix_http::http::Method;
-use actix_router::IntoPattern;
 use std::future::Future;
 
+use actix_http::http::Method;
 pub use actix_http::Response as HttpResponse;
+use actix_router::IntoPatterns;
 pub use bytes::{Buf, BufMut, Bytes, BytesMut};
 
 use crate::error::BlockingError;
@@ -51,7 +51,7 @@ pub use crate::types::*;
 ///         .route(web::head().to(|| HttpResponse::MethodNotAllowed()))
 /// );
 /// ```
-pub fn resource<T: IntoPattern>(path: T) -> Resource {
+pub fn resource<T: IntoPatterns>(path: T) -> Resource {
     Resource::new(path)
 }
 
@@ -268,7 +268,7 @@ where
 ///         .finish(my_service)
 /// );
 /// ```
-pub fn service<T: IntoPattern>(path: T) -> WebService {
+pub fn service<T: IntoPatterns>(path: T) -> WebService {
     WebService::new(path)
 }