fix no-std

Author: maddeleine

quic/s2n-quic-core/src/packet/handshake.rs

@@ -22,6 +22,8 @@ use crate::{
     transport,
     varint::VarInt,
 };
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
 use s2n_codec::{CheckedRange, DecoderBufferMut, DecoderBufferMutResult, Encoder, EncoderValue};
 
 //= https://www.rfc-editor.org/rfc/rfc9000#section-17.2.4
@@ -65,6 +67,7 @@ pub type EncryptedHandshake<'a> =
 pub type CleartextHandshake<'a> = Handshake<&'a [u8], &'a [u8], PacketNumber, DecoderBufferMut<'a>>;
 
 impl<'a> ProtectedHandshake<'a> {
+    #[cfg(feature = "alloc")]
     pub fn get_wire_bytes(&self) -> Vec<u8> {
         self.payload.buffer.encode_to_vec()
     }

quic/s2n-quic-core/src/packet/short.rs

@@ -16,6 +16,8 @@ use crate::{
     },
     transport,
 };
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
 use s2n_codec::{CheckedRange, DecoderBufferMut, DecoderBufferMutResult, Encoder, EncoderValue};
 
 //= https://www.rfc-editor.org/rfc/rfc9000#section-17.3.1
@@ -194,7 +196,7 @@ impl<'a> ProtectedShort<'a> {
             .get_checked_range(&self.destination_connection_id)
             .into_less_safe_slice()
     }
-
+    #[cfg(feature = "alloc")]
     pub fn get_wire_bytes(&self) -> Vec<u8> {
         self.payload.buffer.encode_to_vec()
     }

quic/s2n-quic-transport/src/connection/connection_impl.rs

@@ -379,7 +379,6 @@ impl<Config: endpoint::Config> ConnectionImpl<Config> {
                         connection_id_validator,
                     )?;
                 }
-                ()
             }
         }
 
@@ -1599,42 +1598,39 @@ impl<Config: endpoint::Config> connection::Trait for ConnectionImpl<Config> {
 
             // notify the connection a packet was processed
             self.on_processed_packet(&processed_packet, subscriber)?;
-        } else {
-            if (self.stored_packet_type.is_none()
-                || self.stored_packet_type == Some(PacketNumberSpace::Handshake))
-                && !self.space_manager.is_handshake_confirmed()
-            {
-                //= https://www.rfc-editor.org/rfc/rfc9001#section-4.1.4
-                //# However, a TLS implementation could perform some of its processing
-                //# asynchronously.  In particular, the process of validating a
-                //# certificate can take some time.  While waiting for TLS processing to
-                //# complete, an endpoint SHOULD buffer received packets if they might be
-                //# processed using keys that are not yet available.  These packets can
-                //# be processed once keys are provided by TLS.  An endpoint SHOULD
-                //# continue to respond to packets that can be processed during this
-                //# time.
-
-                // https://www.rfc-editor.org/rfc/rfc9000#section-5.2.1
-                //# Due to packet reordering or loss, a client might receive packets
-                //# for a connection that are encrypted with a key it has not yet computed.
-                //# The client MAY drop these packets, or it MAY buffer them in anticipation
-                //# of later packets that allow it to compute the key.
-
-                let packet_bytes = packet.get_wire_bytes();
-                if packet_bytes.len() + self.packet_storage.len() < self.limits.stored_packet_size()
-                {
-                    self.packet_storage.extend(packet_bytes);
-                    self.stored_packet_type = Some(PacketNumberSpace::Handshake)
-                }
-            } else {
-                let path = &self.path_manager[path_id];
-                publisher.on_packet_dropped(event::builder::PacketDropped {
-                    reason: event::builder::PacketDropReason::PacketSpaceDoesNotExist {
-                        path: path_event!(path, path_id),
-                        packet_type: event::builder::PacketType::Handshake,
-                    },
-                });
+        } else if (self.stored_packet_type.is_none()
+            || self.stored_packet_type == Some(PacketNumberSpace::Handshake))
+            && !self.space_manager.is_handshake_confirmed()
+        {
+            //= https://www.rfc-editor.org/rfc/rfc9001#section-4.1.4
+            //# However, a TLS implementation could perform some of its processing
+            //# asynchronously.  In particular, the process of validating a
+            //# certificate can take some time.  While waiting for TLS processing to
+            //# complete, an endpoint SHOULD buffer received packets if they might be
+            //# processed using keys that are not yet available.  These packets can
+            //# be processed once keys are provided by TLS.  An endpoint SHOULD
+            //# continue to respond to packets that can be processed during this
+            //# time.
+
+            // https://www.rfc-editor.org/rfc/rfc9000#section-5.2.1
+            //# Due to packet reordering or loss, a client might receive packets
+            //# for a connection that are encrypted with a key it has not yet computed.
+            //# The client MAY drop these packets, or it MAY buffer them in anticipation
+            //# of later packets that allow it to compute the key.
+
+            let packet_bytes = packet.get_wire_bytes();
+            if packet_bytes.len() + self.packet_storage.len() < self.limits.stored_packet_size() {
+                self.packet_storage.extend(packet_bytes);
+                self.stored_packet_type = Some(PacketNumberSpace::Handshake)
             }
+        } else {
+            let path = &self.path_manager[path_id];
+            publisher.on_packet_dropped(event::builder::PacketDropped {
+                reason: event::builder::PacketDropReason::PacketSpaceDoesNotExist {
+                    path: path_event!(path, path_id),
+                    packet_type: event::builder::PacketType::Handshake,
+                },
+            });
         }
 
         Ok(())