fix: remove slicur

Author: cxw620

Cargo.lock

@@ -22,7 +22,7 @@ tokio = { version = "1.40", optional = true }
 nix = { version = "0.30.1", features = ["socket", "uio", "net"] }
 bitflags = "2.9"
 pin-project = "1.1"
-slicur = { version = "0.2.0", default-features = false, features = ["feat-u24"] }
+
 
 [dev-dependencies]
 rand = "0.9.2"

ktls/Cargo.toml

@@ -5,14 +5,14 @@ use std::os::fd::{AsFd, AsRawFd};
 use std::{io, mem, ops};
 
 use rustls::client::ClientConnectionData;
+use rustls::internal::msgs::codec::Reader;
 use rustls::internal::msgs::enums::AlertLevel;
 use rustls::kernel::KernelConnection;
 use rustls::server::ServerConnectionData;
 use rustls::{
     AlertDescription, ConnectionTrafficSecrets, ContentType, HandshakeType, InvalidMessage,
     PeerMisbehaved, ProtocolVersion, SupportedCipherSuite,
 };
-use slicur::Reader;
 
 use crate::protocol::{KeyUpdateRequest, KEY_UPDATE_NOT_REQUESTED, KEY_UPDATE_REQUESTED};
 use crate::setup::{setup_tls_params_rx, setup_tls_params_tx};
@@ -411,21 +411,24 @@ impl Context {
         stream: &IO,
         payload: &[u8],
     ) -> io::Result<()> {
-        fn read_message<'a>(
-            reader: &mut Reader<'a>,
-        ) -> Result<(HandshakeType, &'a [u8]), slicur::error::InsufficientData> {
-            let handshake_type = HandshakeType::from(reader.read_u8()?);
-            let length = reader.read_u24()?;
-            let payload = reader.take(length.to_usize())?;
-
-            Ok((handshake_type, payload))
+        fn read_message<'a>(reader: &mut Reader<'a>) -> Option<(HandshakeType, &'a [u8])> {
+            let &[typ, a, b, c] = reader.take(4)? else {
+                unreachable!()
+            };
+
+            let handshake_type = HandshakeType::from(typ);
+            let length = u32::from_be_bytes([0, a, b, c]) as usize;
+
+            let payload = reader.take(length)?;
+
+            Some((handshake_type, payload))
         }
 
         let mut reader = Reader::init(payload);
         let mut sub_message_count = 0;
 
         loop {
-            let Ok((handshake_type, payload)) = read_message(&mut reader) else {
+            let Some((handshake_type, payload)) = read_message(&mut reader) else {
                 abort_and_return_error!(
                     self,
                     stream,