fix: resolve rkyv alignment issues with aligned buffer copy

Co-authored-by: doublegate <6858123+doublegate@users.noreply.github.com>

Author: Copilot

crates/prtip-scanner/Cargo.toml

@@ -87,7 +87,7 @@ pcap-file = "2.0"
 
 # Memory-mapped I/O
 memmap2 = { workspace = true }
-rkyv = { workspace = true }
+rkyv = { workspace = true, features = ["alloc"] }
 
 [dev-dependencies]
 tokio = { workspace = true }

crates/prtip-scanner/src/output/mmap_reader.rs

@@ -8,6 +8,7 @@ use std::path::Path;
 
 const HEADER_SIZE: usize = 64;
 const ENTRY_SIZE: usize = 512;
+const LENGTH_PREFIX_SIZE: usize = 8; // 8 bytes for length to maintain alignment
 
 /// Memory-mapped result reader
 pub struct MmapResultReader {
@@ -75,22 +76,21 @@ impl MmapResultReader {
         }
 
         let offset = HEADER_SIZE + (index * self.entry_size);
-        let entry_bytes = &self.mmap[offset..offset + self.entry_size];
-
-        // Find the end of actual data (before zero-padding)
-        let data_end = entry_bytes.iter()
-            .rposition(|&b| b != 0)
-            .map(|pos| pos + 1)
-            .unwrap_or(0);
 
-        if data_end == 0 {
+        // Read length prefix (8 bytes)
+        let len_bytes: [u8; 8] = self.mmap[offset..offset + LENGTH_PREFIX_SIZE].try_into().ok()?;
+        let len = u64::from_le_bytes(len_bytes) as usize;
+        
+        if len == 0 || len + LENGTH_PREFIX_SIZE > self.entry_size {
             return None;
         }
 
-        let actual_bytes = &entry_bytes[..data_end];
+        // Copy data to an aligned buffer (rkyv requires alignment)
+        let entry_bytes = &self.mmap[offset + LENGTH_PREFIX_SIZE..offset + LENGTH_PREFIX_SIZE + len];
+        let aligned_data: Vec<u8> = entry_bytes.to_vec();
 
         // Deserialize using rkyv
-        match rkyv::from_bytes::<ScanResultRkyv, rkyv::rancor::Error>(actual_bytes) {
+        match rkyv::from_bytes::<ScanResultRkyv, rkyv::rancor::Error>(&aligned_data) {
             Ok(rkyv_result) => Some(rkyv_result.into()),
             Err(_) => None,
         }

crates/prtip-scanner/src/output/mmap_writer.rs

@@ -12,6 +12,7 @@ use std::path::Path;
 
 const HEADER_SIZE: usize = 64; // Version, entry_count, entry_size, checksum
 const ENTRY_SIZE: usize = 512; // Fixed-size entries (padded if needed)
+const LENGTH_PREFIX_SIZE: usize = 8; // 8 bytes for length to maintain alignment
 
 /// Memory-mapped result writer
 pub struct MmapResultWriter {
@@ -62,22 +63,28 @@ impl MmapResultWriter {
         let entry_bytes = rkyv::to_bytes::<rkyv::rancor::Error>(&rkyv_result)
             .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?;
 
-        if entry_bytes.len() > ENTRY_SIZE {
+        // Check if data + length prefix fits
+        if entry_bytes.len() + LENGTH_PREFIX_SIZE > ENTRY_SIZE {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 format!(
-                    "Entry size {} exceeds maximum {}",
+                    "Entry size {} (+{} length) exceeds maximum {}",
                     entry_bytes.len(),
+                    LENGTH_PREFIX_SIZE,
                     ENTRY_SIZE
                 ),
             ));
         }
 
-        // Write serialized data
-        self.mmap[offset..offset + entry_bytes.len()].copy_from_slice(&entry_bytes);
+        // Write length prefix (8 bytes for alignment)
+        let len = entry_bytes.len() as u64;
+        self.mmap[offset..offset + LENGTH_PREFIX_SIZE].copy_from_slice(&len.to_le_bytes());
+
+        // Write serialized data after length prefix
+        self.mmap[offset + LENGTH_PREFIX_SIZE..offset + LENGTH_PREFIX_SIZE + entry_bytes.len()].copy_from_slice(&entry_bytes);
 
         // Zero-fill remaining space
-        for i in entry_bytes.len()..ENTRY_SIZE {
+        for i in (LENGTH_PREFIX_SIZE + entry_bytes.len())..ENTRY_SIZE {
             self.mmap[offset + i] = 0;
         }