Fixed unsoundness in .and_then()/.then() service combinators

Author: fafhrd91

actix-service/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [1.0.5] - 2020-01-16
+
+### Fixed
+
+* Fixed unsoundness in .and_then()/.then() service combinators
+
 ## [1.0.4] - 2020-01-15
 
 ### Fixed

actix-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-service"
-version = "1.0.4"
+version = "1.0.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix service"
 keywords = ["network", "framework", "async", "futures"]

actix-service/src/and_then.rs

@@ -1,5 +1,6 @@
 use std::future::Future;
 use std::pin::Pin;
+use std::rc::Rc;
 use std::task::{Context, Poll};
 
 use super::{Service, ServiceFactory};
@@ -9,7 +10,7 @@ use crate::cell::Cell;
 /// of another service which completes successfully.
 ///
 /// This is created by the `ServiceExt::and_then` method.
-pub struct AndThenService<A, B>(Cell<A>, Cell<B>);
+pub(crate) struct AndThenService<A, B>(Cell<(A, B)>);
 
 impl<A, B> AndThenService<A, B> {
     /// Create new `AndThen` combinator
@@ -18,13 +19,13 @@ impl<A, B> AndThenService<A, B> {
         A: Service,
         B: Service<Request = A::Response, Error = A::Error>,
     {
-        Self(Cell::new(a), Cell::new(b))
+        Self(Cell::new((a, b)))
     }
 }
 
 impl<A, B> Clone for AndThenService<A, B> {
     fn clone(&self) -> Self {
-        AndThenService(self.0.clone(), self.1.clone())
+        AndThenService(self.0.clone())
     }
 }
 
@@ -39,8 +40,9 @@ where
     type Future = AndThenServiceResponse<A, B>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let not_ready = { !self.0.get_mut().poll_ready(cx)?.is_ready() };
-        if !self.1.poll_ready(cx)?.is_ready() || not_ready {
+        let srv = self.0.get_mut();
+        let not_ready = !srv.0.poll_ready(cx)?.is_ready();
+        if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
@@ -49,13 +51,13 @@ where
 
     fn call(&mut self, req: A::Request) -> Self::Future {
         AndThenServiceResponse {
-            state: State::A(self.0.get_mut().call(req), Some(self.1.clone())),
+            state: State::A(self.0.get_mut().0.call(req), Some(self.0.clone())),
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct AndThenServiceResponse<A, B>
+pub(crate) struct AndThenServiceResponse<A, B>
 where
     A: Service,
     B: Service<Request = A::Response, Error = A::Error>,
@@ -70,7 +72,7 @@ where
     A: Service,
     B: Service<Request = A::Response, Error = A::Error>,
 {
-    A(#[pin] A::Future, Option<Cell<B>>),
+    A(#[pin] A::Future, Option<Cell<(A, B)>>),
     B(#[pin] B::Future),
     Empty,
 }
@@ -92,7 +94,7 @@ where
                 Poll::Ready(res) => {
                     let mut b = b.take().unwrap();
                     this.state.set(State::Empty); // drop fut A
-                    let fut = b.get_mut().call(res);
+                    let fut = b.get_mut().1.call(res);
                     this.state.set(State::B(fut));
                     self.poll(cx)
                 }
@@ -108,7 +110,7 @@ where
 }
 
 /// `.and_then()` service factory combinator
-pub struct AndThenServiceFactory<A, B>
+pub(crate) struct AndThenServiceFactory<A, B>
 where
     A: ServiceFactory,
     A::Config: Clone,
@@ -119,8 +121,7 @@ where
         InitError = A::InitError,
     >,
 {
-    a: A,
-    b: B,
+    inner: Rc<(A, B)>,
 }
 
 impl<A, B> AndThenServiceFactory<A, B>
@@ -136,7 +137,9 @@ where
 {
     /// Create new `AndThenFactory` combinator
     pub(crate) fn new(a: A, b: B) -> Self {
-        Self { a, b }
+        Self {
+            inner: Rc::new((a, b)),
+        }
     }
 }
 
@@ -161,34 +164,34 @@ where
     type Future = AndThenServiceFactoryResponse<A, B>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
+        let inner = &*self.inner;
         AndThenServiceFactoryResponse::new(
-            self.a.new_service(cfg.clone()),
-            self.b.new_service(cfg),
+            inner.0.new_service(cfg.clone()),
+            inner.1.new_service(cfg),
         )
     }
 }
 
 impl<A, B> Clone for AndThenServiceFactory<A, B>
 where
-    A: ServiceFactory + Clone,
+    A: ServiceFactory,
     A::Config: Clone,
     B: ServiceFactory<
-            Config = A::Config,
-            Request = A::Response,
-            Error = A::Error,
-            InitError = A::InitError,
-        > + Clone,
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     fn clone(&self) -> Self {
         Self {
-            a: self.a.clone(),
-            b: self.b.clone(),
+            inner: self.inner.clone(),
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct AndThenServiceFactoryResponse<A, B>
+pub(crate) struct AndThenServiceFactoryResponse<A, B>
 where
     A: ServiceFactory,
     B: ServiceFactory<Request = A::Response>,

actix-service/src/and_then_apply_fn.rs

@@ -1,22 +1,22 @@
 use std::future::Future;
 use std::marker::PhantomData;
 use std::pin::Pin;
+use std::rc::Rc;
 use std::task::{Context, Poll};
 
 use crate::cell::Cell;
 use crate::{Service, ServiceFactory};
 
 /// `Apply` service combinator
-pub struct AndThenApplyFn<A, B, F, Fut, Res, Err>
+pub(crate) struct AndThenApplyFn<A, B, F, Fut, Res, Err>
 where
     A: Service,
     B: Service,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
 {
-    a: A,
-    b: Cell<(B, F)>,
+    srv: Cell<(A, B, F)>,
     r: PhantomData<(Fut, Res, Err)>,
 }
 
@@ -31,25 +31,23 @@ where
     /// Create new `Apply` combinator
     pub(crate) fn new(a: A, b: B, f: F) -> Self {
         Self {
-            a,
-            b: Cell::new((b, f)),
+            srv: Cell::new((a, b, f)),
             r: PhantomData,
         }
     }
 }
 
 impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFn<A, B, F, Fut, Res, Err>
 where
-    A: Service + Clone,
+    A: Service,
     B: Service,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
 {
     fn clone(&self) -> Self {
         AndThenApplyFn {
-            a: self.a.clone(),
-            b: self.b.clone(),
+            srv: self.srv.clone(),
             r: PhantomData,
         }
     }
@@ -69,23 +67,25 @@ where
     type Future = AndThenApplyFnFuture<A, B, F, Fut, Res, Err>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let not_ready = self.a.poll_ready(cx)?.is_pending();
-        if self.b.get_mut().0.poll_ready(cx)?.is_pending() || not_ready {
+        let inner = self.srv.get_mut();
+        let not_ready = inner.0.poll_ready(cx)?.is_pending();
+        if inner.1.poll_ready(cx)?.is_pending() || not_ready {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
         }
     }
 
     fn call(&mut self, req: A::Request) -> Self::Future {
+        let fut = self.srv.get_mut().0.call(req);
         AndThenApplyFnFuture {
-            state: State::A(self.a.call(req), Some(self.b.clone())),
+            state: State::A(fut, Some(self.srv.clone())),
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
+pub(crate) struct AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
 where
     A: Service,
     B: Service,
@@ -108,7 +108,7 @@ where
     Err: From<A::Error>,
     Err: From<B::Error>,
 {
-    A(#[pin] A::Future, Option<Cell<(B, F)>>),
+    A(#[pin] A::Future, Option<Cell<(A, B, F)>>),
     B(#[pin] Fut),
     Empty,
 }
@@ -134,7 +134,7 @@ where
                     let mut b = b.take().unwrap();
                     this.state.set(State::Empty);
                     let b = b.get_mut();
-                    let fut = (&mut b.1)(res, &mut b.0);
+                    let fut = (&mut b.2)(res, &mut b.1);
                     this.state.set(State::B(fut));
                     self.poll(cx)
                 }
@@ -150,10 +150,8 @@ where
 }
 
 /// `AndThenApplyFn` service factory
-pub struct AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
-    a: A,
-    b: B,
-    f: F,
+pub(crate) struct AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
+    srv: Rc<(A, B, F)>,
     r: PhantomData<(Fut, Res, Err)>,
 }
 
@@ -168,25 +166,16 @@ where
     /// Create new `ApplyNewService` new service instance
     pub(crate) fn new(a: A, b: B, f: F) -> Self {
         Self {
-            a: a,
-            b: b,
-            f: f,
+            srv: Rc::new((a, b, f)),
             r: PhantomData,
         }
     }
 }
 
-impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
-where
-    A: Clone,
-    B: Clone,
-    F: Clone,
-{
+impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
     fn clone(&self) -> Self {
         Self {
-            a: self.a.clone(),
-            b: self.b.clone(),
-            f: self.f.clone(),
+            srv: self.srv.clone(),
             r: PhantomData,
         }
     }
@@ -210,18 +199,19 @@ where
     type Future = AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
+        let srv = &*self.srv;
         AndThenApplyFnFactoryResponse {
             a: None,
             b: None,
-            f: self.f.clone(),
-            fut_a: self.a.new_service(cfg.clone()),
-            fut_b: self.b.new_service(cfg),
+            f: srv.2.clone(),
+            fut_a: srv.0.new_service(cfg.clone()),
+            fut_b: srv.1.new_service(cfg),
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
+pub(crate) struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
 where
     A: ServiceFactory,
     B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
@@ -267,8 +257,11 @@ where
 
         if this.a.is_some() && this.b.is_some() {
             Poll::Ready(Ok(AndThenApplyFn {
-                a: this.a.take().unwrap(),
-                b: Cell::new((this.b.take().unwrap(), this.f.clone())),
+                srv: Cell::new((
+                    this.a.take().unwrap(),
+                    this.b.take().unwrap(),
+                    this.f.clone(),
+                )),
                 r: PhantomData,
             }))
         } else {