Merge branch 'main' into fix-send-buffer

Author: rklaehn

.github/workflows/tests.yaml

@@ -170,6 +170,8 @@ jobs:
       # Using self-hosted runners so use local cache for sccache and
       # not SCCACHE_GHA_ENABLED.
       RUSTC_WRAPPER: "sccache"
+      # Force clang/bindgen to use MSVC target to avoid mingw headers from msys2
+      BINDGEN_EXTRA_CLANG_ARGS: "--target=x86_64-pc-windows-msvc"
     steps:
       - name: Checkout
         uses: actions/checkout@v6
@@ -274,6 +276,9 @@ jobs:
           echo "C:\Program Files\LLVM\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
           echo "LIBCLANG_PATH=C:\Program Files\LLVM\bin" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 
+      - name: Setup MSVC dev environment
+        uses: ilammy/msvc-dev-cmd@v1
+
       - name: build tests
         run: |
           cargo nextest run --workspace --exclude fuzz ${{ env.FEATURES }} --lib --bins --tests --target ${{ matrix.target }} --no-run

quinn-proto/src/cid_queue.rs

@@ -14,7 +14,7 @@ struct CidData(ConnectionId, Option<ResetToken>);
 /// - Zero to `Self::LEN - 1` reserved CIDs from `self.cursor` up to `self.cursor_reserved`.
 /// - More "available"/"ready" CIDs after `self.cursor_reserved`.
 ///
-/// The range of reserved CIDs is grown by calling [`CidQueue::next_reserved`], which takes one of
+/// The range of reserved CIDs is grown by calling `CidQueue::next_reserved`, which takes one of
 /// the available ones and returns the CID that was reserved.
 ///
 /// New available/ready CIDs are added by calling [`CidQueue::insert`].

quinn-proto/src/coding.rs

@@ -15,63 +15,75 @@ pub struct UnexpectedEnd;
 /// Coding result type
 pub type Result<T> = ::std::result::Result<T, UnexpectedEnd>;
 
-/// Infallible encoding and decoding of QUIC primitives
-pub trait Codec: Sized {
+/// Infallible encoding of QUIC primitives.
+pub trait Encodable {
+    /// Append the encoding of `self` to the provided buffer.
+    fn encode<B: BufMut>(&self, buf: &mut B);
+}
+
+/// Decoding of QUIC primitives.
+pub trait Decodable: Sized {
     /// Decode a `Self` from the provided buffer, if the buffer is large enough
     fn decode<B: Buf>(buf: &mut B) -> Result<Self>;
-    /// Append the encoding of `self` to the provided buffer
-    fn encode<B: BufMut>(&self, buf: &mut B);
 }
 
-impl Codec for u8 {
+impl Decodable for u8 {
     fn decode<B: Buf>(buf: &mut B) -> Result<Self> {
         if buf.remaining() < 1 {
             return Err(UnexpectedEnd);
         }
         Ok(buf.get_u8())
     }
+}
+impl Encodable for u8 {
     fn encode<B: BufMut>(&self, buf: &mut B) {
         buf.put_u8(*self);
     }
 }
 
-impl Codec for u16 {
+impl Decodable for u16 {
     fn decode<B: Buf>(buf: &mut B) -> Result<Self> {
         if buf.remaining() < 2 {
             return Err(UnexpectedEnd);
         }
         Ok(buf.get_u16())
     }
+}
+impl Encodable for u16 {
     fn encode<B: BufMut>(&self, buf: &mut B) {
         buf.put_u16(*self);
     }
 }
 
-impl Codec for u32 {
+impl Decodable for u32 {
     fn decode<B: Buf>(buf: &mut B) -> Result<Self> {
         if buf.remaining() < 4 {
             return Err(UnexpectedEnd);
         }
         Ok(buf.get_u32())
     }
+}
+impl Encodable for u32 {
     fn encode<B: BufMut>(&self, buf: &mut B) {
         buf.put_u32(*self);
     }
 }
 
-impl Codec for u64 {
+impl Decodable for u64 {
     fn decode<B: Buf>(buf: &mut B) -> Result<Self> {
         if buf.remaining() < 8 {
             return Err(UnexpectedEnd);
         }
         Ok(buf.get_u64())
     }
+}
+impl Encodable for u64 {
     fn encode<B: BufMut>(&self, buf: &mut B) {
         buf.put_u64(*self);
     }
 }
 
-impl Codec for Ipv4Addr {
+impl Decodable for Ipv4Addr {
     fn decode<B: Buf>(buf: &mut B) -> Result<Self> {
         if buf.remaining() < 4 {
             return Err(UnexpectedEnd);
@@ -80,12 +92,14 @@ impl Codec for Ipv4Addr {
         buf.copy_to_slice(&mut octets);
         Ok(octets.into())
     }
+}
+impl Encodable for Ipv4Addr {
     fn encode<B: BufMut>(&self, buf: &mut B) {
         buf.put_slice(&self.octets());
     }
 }
 
-impl Codec for Ipv6Addr {
+impl Decodable for Ipv6Addr {
     fn decode<B: Buf>(buf: &mut B) -> Result<Self> {
         if buf.remaining() < 16 {
             return Err(UnexpectedEnd);
@@ -94,18 +108,20 @@ impl Codec for Ipv6Addr {
         buf.copy_to_slice(&mut octets);
         Ok(octets.into())
     }
+}
+impl Encodable for Ipv6Addr {
     fn encode<B: BufMut>(&self, buf: &mut B) {
         buf.put_slice(&self.octets());
     }
 }
 
 pub(crate) trait BufExt {
-    fn get<T: Codec>(&mut self) -> Result<T>;
+    fn get<T: Decodable>(&mut self) -> Result<T>;
     fn get_var(&mut self) -> Result<u64>;
 }
 
 impl<T: Buf> BufExt for T {
-    fn get<U: Codec>(&mut self) -> Result<U> {
+    fn get<U: Decodable>(&mut self) -> Result<U> {
         U::decode(self)
     }
 
@@ -115,12 +131,12 @@ impl<T: Buf> BufExt for T {
 }
 
 pub(crate) trait BufMutExt {
-    fn write<T: Codec>(&mut self, x: T);
+    fn write<T: Encodable>(&mut self, x: T);
     fn write_var(&mut self, x: u64);
 }
 
 impl<T: BufMut> BufMutExt for T {
-    fn write<U: Codec>(&mut self, x: U) {
+    fn write<U: Encodable>(&mut self, x: U) {
         x.encode(self);
     }
 

quinn-proto/src/config/qlog.rs

@@ -10,7 +10,7 @@ use crate::{ConnectionId, Instant, Side};
 ///
 /// This is set via [`TransportConfig::qlog_factory`].
 ///
-/// [`TransportConfig::qlog_factory]: crate::config::TransportConfig::qlog_factory
+/// [`TransportConfig::qlog_factory`]: crate::TransportConfig::qlog_factory
 pub trait QlogFactory: Send + Sync + 'static {
     /// Returns a [`QlogConfig`] for a connection, if logging should be enabled.
     ///