Fix excessive stack sizes

algesten · algesten · commit 25094379886a · 2025-01-27T07:29:14.000+01:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -599,8 +599,9 @@ pub(crate) mod test {
     use std::io;
 
     use assert_no_alloc::AllocDisabler;
-    use config::Config;
+    use config::{Config, ConfigBuilder};
     use once_cell::sync::Lazy;
+    use typestate::AgentScope;
 
     use super::*;
 
@@ -988,6 +989,30 @@ pub(crate) mod test {
         res.body_mut().read_to_string().unwrap();
     }
 
+    #[test]
+    fn ensure_reasonable_stack_sizes() {
+        macro_rules! ensure {
+            ($type:ty, $size:tt) => {
+                let sz = std::mem::size_of::<$type>();
+                // println!("{}: {}", stringify!($type), sz);
+                assert!(
+                    sz <= $size,
+                    "Stack size of {} is too big {} > {}",
+                    stringify!($type),
+                    sz,
+                    $size
+                );
+            };
+        }
+
+        ensure!(RequestBuilder<WithoutBody>, 400); // 288
+        ensure!(Agent, 100); // 32
+        ensure!(Config, 400); // 320
+        ensure!(ConfigBuilder<AgentScope>, 400); // 320
+        ensure!(Response<Body>, 800); // 760
+        ensure!(Body, 700); // 648
+    }
+
     // This doesn't need to run, just compile.
     fn _ensure_send_sync() {
         fn is_send(_t: impl Send) {}
diff --git a/src/run.rs b/src/run.rs
@@ -550,7 +550,7 @@ pub(crate) struct BodyHandler {
     connection: Option<Connection>,
     timings: CallTimings,
     remote_closed: bool,
-    redirect: Option<Flow<Redirect>>,
+    redirect: Option<Box<Flow<Redirect>>>,
 }
 
 impl BodyHandler {
@@ -651,7 +651,7 @@ impl BodyHandler {
         let must_close_connection = match flow.proceed().unwrap() {
             RecvBodyResult::Redirect(flow) => {
                 let c = flow.must_close_connection();
-                self.redirect = Some(flow);
+                self.redirect = Some(Box::new(flow));
                 c
             }
             RecvBodyResult::Cleanup(v) => v.must_close_connection(),
@@ -674,7 +674,7 @@ impl BodyHandler {
 
         // Unwrap is OK, because we are only consuming the redirect body if
         // such a body was signalled by the remote.
-        let redirect = self.redirect.take();
+        let redirect = self.redirect.take().map(|b| *b);
         Ok(redirect.expect("remote to have signaled redirect"))
     }
 }
diff --git a/src/timings.rs b/src/timings.rs
@@ -1,6 +1,5 @@
 use std::fmt;
 use std::sync::Arc;
-use ureq_proto::ArrayVec;
 
 use crate::config::Timeouts;
 use crate::transport::time::{Duration, Instant};
@@ -84,35 +83,31 @@ impl Timeout {
 
 #[derive(Debug)]
 pub(crate) struct CallTimings {
-    timeouts: Timeouts,
+    timeouts: Box<Timeouts>,
     current_time: CurrentTime,
-    times: ArrayVec<(Timeout, Instant), 8>,
+    times: Vec<(Timeout, Instant)>,
 }
 
 impl Default for CallTimings {
     fn default() -> Self {
         Self {
             timeouts: Default::default(),
             current_time: Default::default(),
-            times: empty_times(),
+            times: vec![],
         }
     }
 }
 
-fn empty_times() -> ArrayVec<(Timeout, Instant), 8> {
-    ArrayVec::from_fn(|_| (Timeout::Global, Instant::AlreadyHappened))
-}
-
 impl CallTimings {
     pub(crate) fn new(timeouts: Timeouts, current_time: CurrentTime) -> Self {
-        let mut times = empty_times();
+        let mut times = Vec::with_capacity(8);
 
         let now = current_time.now();
         times.push((Timeout::Global, now));
         times.push((Timeout::PerCall, now));
 
         CallTimings {
-            timeouts,
+            timeouts: Box::new(timeouts),
             current_time,
             times,
         }

Original file line number	Diff line number	Diff line change
`@@ -550,7 +550,7 @@ pub(crate) struct BodyHandler {`
`550`	`550`	`connection: Option<Connection>,`
`551`	`551`	`timings: CallTimings,`
`552`	`552`	`remote_closed: bool,`
`553`		`- redirect: Option<Flow<Redirect>>,`
	`553`	`+ redirect: Option<Box<Flow<Redirect>>>,`
`554`	`554`	`}`
`555`	`555`
`556`	`556`	`impl BodyHandler {`
`@@ -651,7 +651,7 @@ impl BodyHandler {`
`651`	`651`	`let must_close_connection = match flow.proceed().unwrap() {`
`652`	`652`	`RecvBodyResult::Redirect(flow) => {`
`653`	`653`	`let c = flow.must_close_connection();`
`654`		`- self.redirect = Some(flow);`
	`654`	`+ self.redirect = Some(Box::new(flow));`
`655`	`655`	`c`
`656`	`656`	`}`
`657`	`657`	`RecvBodyResult::Cleanup(v) => v.must_close_connection(),`
`@@ -674,7 +674,7 @@ impl BodyHandler {`
`674`	`674`
`675`	`675`	`// Unwrap is OK, because we are only consuming the redirect body if`
`676`	`676`	`// such a body was signalled by the remote.`
`677`		`- let redirect = self.redirect.take();`
	`677`	`+ let redirect = self.redirect.take().map(\|b\| *b);`
`678`	`678`	`Ok(redirect.expect("remote to have signaled redirect"))`
`679`	`679`	`}`
`680`	`680`	`}`