de-generify FramedRead::decode_frame (#509)

* de-generify FramedRead::decode_frame

* Rename arg to decode_frame

Co-authored-by: Dan Burkert <dan@danburkert.com>

src/codec/framed_read.rs

@@ -59,7 +59,46 @@ impl<T> FramedRead<T> {
         }
     }
 
-    fn decode_frame(&mut self, mut bytes: BytesMut) -> Result<Option<Frame>, RecvError> {
+    pub fn get_ref(&self) -> &T {
+        self.inner.get_ref()
+    }
+
+    pub fn get_mut(&mut self) -> &mut T {
+        self.inner.get_mut()
+    }
+
+    /// Returns the current max frame size setting
+    #[cfg(feature = "unstable")]
+    #[inline]
+    pub fn max_frame_size(&self) -> usize {
+        self.inner.decoder().max_frame_length()
+    }
+
+    /// Updates the max frame size setting.
+    ///
+    /// Must be within 16,384 and 16,777,215.
+    #[inline]
+    pub fn set_max_frame_size(&mut self, val: usize) {
+        assert!(DEFAULT_MAX_FRAME_SIZE as usize <= val && val <= MAX_MAX_FRAME_SIZE as usize);
+        self.inner.decoder_mut().set_max_frame_length(val)
+    }
+
+    /// Update the max header list size setting.
+    #[inline]
+    pub fn set_max_header_list_size(&mut self, val: usize) {
+        self.max_header_list_size = val;
+    }
+}
+
+/// Decodes a frame.
+///
+/// This method is intentionally de-generified and outlined because it is very large.
+fn decode_frame(
+    hpack: &mut hpack::Decoder,
+    max_header_list_size: usize,
+    partial_inout: &mut Option<Partial>,
+    mut bytes: BytesMut,
+) -> Result<Option<Frame>, RecvError> {
     use self::RecvError::*;
     let span = tracing::trace_span!("FramedRead::decode_frame", offset = bytes.len());
     let _e = span.enter();
@@ -69,7 +108,7 @@ impl<T> FramedRead<T> {
     // Parse the head
     let head = frame::Head::parse(&bytes);
 
-        if self.partial.is_some() && head.kind() != Kind::Continuation {
+    if partial_inout.is_some() && head.kind() != Kind::Continuation {
         proto_err!(conn: "expected CONTINUATION, got {:?}", head.kind());
         return Err(Connection(Reason::PROTOCOL_ERROR));
     }
@@ -106,7 +145,7 @@ impl<T> FramedRead<T> {
             let is_end_headers = frame.is_end_headers();
 
             // Load the HPACK encoded headers
-                match frame.load_hpack(&mut payload, self.max_header_list_size, &mut self.hpack) {
+            match frame.load_hpack(&mut payload, max_header_list_size, hpack) {
                 Ok(_) => {},
                 Err(frame::Error::Hpack(hpack::DecoderError::NeedMore(_))) if !is_end_headers => {},
                 Err(frame::Error::MalformedMessage) => {
@@ -128,7 +167,7 @@ impl<T> FramedRead<T> {
             } else {
                 tracing::trace!("loaded partial header block");
                 // Defer returning the frame
-                    self.partial = Some(Partial {
+                *partial_inout = Some(Partial {
                     frame: Continuable::$frame(frame),
                     buf: payload,
                 });
@@ -224,7 +263,7 @@ impl<T> FramedRead<T> {
         Kind::Continuation => {
             let is_end_headers = (head.flag() & 0x4) == 0x4;
 
-                let mut partial = match self.partial.take() {
+            let mut partial = match partial_inout.take() {
                 Some(partial) => partial,
                 None => {
                     proto_err!(conn: "received unexpected CONTINUATION frame");
@@ -256,7 +295,7 @@ impl<T> FramedRead<T> {
                     // Instead, we use a simple heuristic to determine if
                     // we should continue to ignore decoding, or to tell
                     // the attacker to go away.
-                        if partial.buf.len() + bytes.len() > self.max_header_list_size {
+                    if partial.buf.len() + bytes.len() > max_header_list_size {
                         proto_err!(conn: "CONTINUATION frame header block size over ignorable limit");
                         return Err(Connection(Reason::COMPRESSION_ERROR));
                     }
@@ -264,14 +303,12 @@ impl<T> FramedRead<T> {
                 partial.buf.extend_from_slice(&bytes[frame::HEADER_LEN..]);
             }
 
-                match partial.frame.load_hpack(
+            match partial
-                    &mut partial.buf,
+                .frame
-                    self.max_header_list_size,
+                .load_hpack(&mut partial.buf, max_header_list_size, hpack)
-                    &mut self.hpack,
+            {
-                ) {
                 Ok(_) => {}
-                    Err(frame::Error::Hpack(hpack::DecoderError::NeedMore(_)))
+                Err(frame::Error::Hpack(hpack::DecoderError::NeedMore(_))) if !is_end_headers => {}
-                        if !is_end_headers => {}
                 Err(frame::Error::MalformedMessage) => {
                     let id = head.stream_id();
                     proto_err!(stream: "malformed CONTINUATION frame; stream={:?}", id);
@@ -289,7 +326,7 @@ impl<T> FramedRead<T> {
             if is_end_headers {
                 partial.frame.into()
             } else {
-                    self.partial = Some(partial);
+                *partial_inout = Some(partial);
                 return Ok(None);
             }
         }
@@ -302,37 +339,6 @@ impl<T> FramedRead<T> {
     Ok(Some(frame))
 }
 
-    pub fn get_ref(&self) -> &T {
-        self.inner.get_ref()
-    }
-
-    pub fn get_mut(&mut self) -> &mut T {
-        self.inner.get_mut()
-    }
-
-    /// Returns the current max frame size setting
-    #[cfg(feature = "unstable")]
-    #[inline]
-    pub fn max_frame_size(&self) -> usize {
-        self.inner.decoder().max_frame_length()
-    }
-
-    /// Updates the max frame size setting.
-    ///
-    /// Must be within 16,384 and 16,777,215.
-    #[inline]
-    pub fn set_max_frame_size(&mut self, val: usize) {
-        assert!(DEFAULT_MAX_FRAME_SIZE as usize <= val && val <= MAX_MAX_FRAME_SIZE as usize);
-        self.inner.decoder_mut().set_max_frame_length(val)
-    }
-
-    /// Update the max header list size setting.
-    #[inline]
-    pub fn set_max_header_list_size(&mut self, val: usize) {
-        self.max_header_list_size = val;
-    }
-}
-
 impl<T> Stream for FramedRead<T>
 where
     T: AsyncRead + Unpin,
@@ -351,7 +357,13 @@ where
             };
 
             tracing::trace!(read.bytes = bytes.len());
-            if let Some(frame) = self.decode_frame(bytes)? {
+            let Self {
+                ref mut hpack,
+                max_header_list_size,
+                ref mut partial,
+                ..
+            } = *self;
+            if let Some(frame) = decode_frame(hpack, max_header_list_size, partial, bytes)? {
                 tracing::debug!(?frame, "received");
                 return Poll::Ready(Some(Ok(frame)));
             }