Remove parse_initial

Redundant to process_early_payload

quinn-proto/src/connection.rs

@@ -820,16 +820,10 @@ impl Connection {
         now: u64,
         ecn: Option<EcnCodepoint>,
         packet_number: u64,
-        payload: Bytes,
+        packet: Packet,
     ) -> Result<(), TransportError> {
-        let frame = if let Ok(Some(frame)) = parse_initial(&self.log, payload) {
-            frame
-        } else {
-            return Ok(());
-        }; // TODO: Send close?
-
+        self.process_early_payload(now, packet)?;
         self.on_packet_authenticated(now, SpaceId::Initial, ecn, Some(packet_number), false);
-        self.read_tls(&frame)?;
         let params = TransportParameters::read(
             Side::Server,
             &mut io::Cursor::new(self.tls.get_quic_transport_parameters().unwrap()),
@@ -1257,7 +1251,7 @@ impl Connection {
     }
 
     /// Process an Initial or Handshake packet payload
-    fn process_early_payload(&mut self, now: u64, packet: Packet) -> Result<(), ConnectionError> {
+    fn process_early_payload(&mut self, now: u64, packet: Packet) -> Result<(), TransportError> {
         debug_assert_ne!(packet.header.space(), SpaceId::OneRtt);
         for frame in frame::Iter::new(packet.payload.into()) {
             match frame {
@@ -1293,7 +1287,7 @@ impl Connection {
                 }
                 _ => {
                     debug!(self.log, "unexpected frame type in handshake"; "type" => %frame.ty());
-                    return Err(TransportError::PROTOCOL_VIOLATION.into());
+                    return Err(TransportError::PROTOCOL_VIOLATION);
                 }
             }
         }
@@ -2404,30 +2398,6 @@ impl Connection {
     }
 }
 
-/// Extract crypto data from the first Initial packet
-fn parse_initial(log: &Logger, payload: Bytes) -> Result<Option<frame::Crypto>, ()> {
-    let mut result = None;
-    for frame in frame::Iter::new(payload) {
-        match frame {
-            Frame::Padding => {}
-            Frame::Ack(_) => {}
-            Frame::ConnectionClose(_) => {}
-            Frame::Crypto(x) => {
-                if x.offset != 0 {
-                    debug!(log, "nonzero offset in first crypto frame"; "offset" => x.offset);
-                    return Err(());
-                }
-                result = Some(x);
-            }
-            x => {
-                debug!(log, "unexpected frame in initial/retry packet"; "ty" => %x.ty());
-                return Err(());
-            } // Invalid packet
-        }
-    }
-    Ok(result)
-}
-
 pub fn handshake_close<R>(
     crypto: &Crypto,
     header_crypto: &HeaderCrypto,

quinn-proto/src/endpoint.rs

@@ -440,9 +440,9 @@ impl Endpoint {
             Header::Initial {
                 src_cid,
                 dst_cid,
-                token,
+                ref token,
                 number,
-            } => (src_cid, dst_cid, token, number),
+            } => (src_cid, dst_cid, token.clone(), number),
             _ => panic!("non-initial packet in handle_initial()"),
         };
         let packet_number = packet_number.expand(0);
@@ -539,12 +539,7 @@ impl Endpoint {
             )
             .unwrap();
         self.connection_ids_initial.insert(dst_cid, conn);
-        match self.connections[conn.0].handle_initial(
-            now,
-            ecn,
-            packet_number as u64,
-            packet.payload.freeze(),
-        ) {
+        match self.connections[conn.0].handle_initial(now, ecn, packet_number as u64, packet) {
             Ok(()) => {
                 self.incoming_handshakes += 1;
                 self.dirty_conns.insert(conn);