fix(client, qpack): align QPACK decoder with protocol spec compliance

.github/workflows/CI.yml

@@ -10,7 +10,7 @@ env:
   core_package_args: >-
     --workspace
     --exclude interop
-  toolchain_style: stable
+  toolchain_style: nightly
   toolchain_msrv: "1.85"
   toolchain_http3_quinn_msrv: "1.85"
   toolchain_doc: nightly
@@ -45,7 +45,7 @@ jobs:
         with:
           toolchain: ${{ env.toolchain_style }}
           components: rustfmt
-      - run: cargo fmt --all -- --check
+      - run: cargo +${{ env.toolchain_style }} fmt --all --check
 
   lint:
     name: Lint

examples/client.rs

@@ -3,10 +3,12 @@ use std::{path::PathBuf, sync::Arc};
 use bytes::{Buf, Bytes};
 use futures::future;
 use http3::error::{Code, ConnectionError, StreamError};
-use rustls::client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier};
-use rustls::crypto::WebPkiSupportedAlgorithms;
-use rustls::pki_types::{CertificateDer, ServerName, UnixTime};
-use rustls::{DigitallySignedStruct, SignatureScheme};
+use rustls::{
+    DigitallySignedStruct, SignatureScheme,
+    client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
+    crypto::WebPkiSupportedAlgorithms,
+    pki_types::{CertificateDer, ServerName, UnixTime},
+};
 use rustls_native_certs::CertificateResult;
 use structopt::StructOpt;
 use tracing::{Level, error, info};

http3-datagram/src/datagram.rs

@@ -88,10 +88,11 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::Datagram;
     use bytes::{Buf, Bytes};
     use http3::quic::StreamId;
 
+    use super::Datagram;
+
     #[test]
     fn encode_preserves_quarter_stream_id() {
         let stream_id = StreamId::try_from(4).unwrap();

http3-quic/src/lib.rs

@@ -26,13 +26,11 @@ compile_error!("features `quinn` and `quic` are mutually exclusive");
 
 #[cfg(all(feature = "quic", not(feature = "quinn")))]
 pub use quic;
-#[cfg(all(feature = "quinn", not(feature = "quic")))]
-pub use quinn as quic;
-
 use quic::ReadError;
 #[cfg(any(feature = "quinn", feature = "quic"))]
 pub use quic::{AcceptBi, AcceptUni, Endpoint, OpenBi, OpenUni, VarInt};
-
+#[cfg(all(feature = "quinn", not(feature = "quic")))]
+pub use quinn as quic;
 use tokio_util::sync::ReusableBoxFuture;
 #[cfg(feature = "tracing")]
 use tracing::instrument;

http3/src/buf.rs

@@ -5,19 +5,21 @@ use bytes::{Buf, Bytes};
 #[derive(Debug)]
 pub(crate) struct BufList<T> {
     bufs: VecDeque<T>,
+    remaining: usize,
 }
 
 impl<T: Buf> BufList<T> {
     pub(crate) fn new() -> BufList<T> {
         BufList {
             bufs: VecDeque::new(),
+            remaining: 0,
         }
     }
 
     #[inline]
-    #[allow(dead_code)]
     pub(crate) fn push(&mut self, buf: T) {
         debug_assert!(buf.has_remaining());
+        self.remaining = self.remaining.saturating_add(buf.remaining());
         self.bufs.push_back(buf);
     }
 
@@ -33,7 +35,9 @@ impl<T: Buf> BufList<T> {
 
 impl BufList<Bytes> {
     pub fn take_first_chunk(&mut self) -> Option<Bytes> {
-        self.bufs.pop_front()
+        let chunk = self.bufs.pop_front()?;
+        self.remaining = self.remaining.saturating_sub(chunk.remaining());
+        Some(chunk)
     }
 
     pub fn take_chunk(&mut self, max_len: usize) -> Option<Bytes> {
@@ -42,6 +46,10 @@ impl BufList<Bytes> {
             .front_mut()
             .map(|chunk| chunk.split_to(usize::min(max_len, chunk.remaining())));
 
+        if let Some(chunk) = chunk.as_ref() {
+            self.remaining = self.remaining.saturating_sub(chunk.remaining());
+        }
+
         if let Some(front) = self.bufs.front() {
             if front.remaining() == 0 {
                 let _ = self.bufs.pop_front();
@@ -55,7 +63,7 @@ impl BufList<Bytes> {
         T: Buf,
     {
         debug_assert!(buf.has_remaining());
-        self.bufs.push_back(buf.copy_to_bytes(buf.remaining()))
+        self.push(buf.copy_to_bytes(buf.remaining()))
     }
 }
 
@@ -71,7 +79,7 @@ impl<T: Buf> From<T> for BufList<T> {
 impl<T: Buf> Buf for BufList<T> {
     #[inline]
     fn remaining(&self) -> usize {
-        self.bufs.iter().map(|buf| buf.remaining()).sum()
+        self.remaining
     }
 
     #[inline]
@@ -81,6 +89,9 @@ impl<T: Buf> Buf for BufList<T> {
 
     #[inline]
     fn advance(&mut self, mut cnt: usize) {
+        assert!(cnt <= self.remaining, "cannot advance past the buffer");
+        self.remaining -= cnt;
+
         while cnt > 0 {
             {
                 let front = &mut self.bufs[0];
@@ -113,6 +124,7 @@ impl<T: Buf> Buf for BufList<T> {
     }
 }
 
+#[derive(Clone)]
 pub struct Cursor<'a, B> {
     buf: &'a BufList<B>,
     pos_total: usize, // position amongst all bytes
@@ -179,4 +191,21 @@ mod tests {
         cur.advance(2);
         assert_eq!(cur.remaining(), 0);
     }
+
+    #[test]
+    fn remaining_tracks_buffer_mutations() {
+        let mut buf = BufList::new();
+        buf.push(Bytes::from_static(b"abc"));
+        buf.push(Bytes::from_static(b"de"));
+        assert_eq!(buf.remaining(), 5);
+
+        assert_eq!(buf.take_chunk(2), Some(Bytes::from_static(b"ab")));
+        assert_eq!(buf.remaining(), 3);
+
+        buf.advance(2);
+        assert_eq!(buf.remaining(), 1);
+
+        assert_eq!(buf.take_first_chunk(), Some(Bytes::from_static(b"e")));
+        assert_eq!(buf.remaining(), 0);
+    }
 }