stackforge 0.6.1__tar.gz → 0.6.2__tar.gz

{stackforge-0.6.1 → stackforge-0.6.2}/Cargo.lock

@@ -1074,7 +1074,7 @@ dependencies = [
 
 [[package]]
 name = "stackforge"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "pyo3",
  "stackforge-automata",
@@ -1083,7 +1083,7 @@ dependencies = [
 
 [[package]]
 name = "stackforge-automata"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "bytes",
  "stackforge-core",
@@ -1091,7 +1091,7 @@ dependencies = [
 
 [[package]]
 name = "stackforge-core"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "aes",
  "aes-gcm",

{stackforge-0.6.1 → stackforge-0.6.2}/Cargo.toml

@@ -21,7 +21,7 @@ shared-version = true
 tag-name = "v{{version}}"
 
 [workspace.package]
-version = "0.6.1"
+version = "0.6.2"
 edition = "2024"
 license = "GPL-3.0-only"
 authors = ["Stackforge Contributors"]

{stackforge-0.6.1 → stackforge-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackforge
-Version: 0.6.1
+Version: 0.6.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators

{stackforge-0.6.1 → stackforge-0.6.2}/crates/stackforge-core/src/flow/spill.rs

@@ -43,17 +43,18 @@ impl ReassemblyStorage {
         self.len() == 0
     }
 
-    /// Append data. Only valid when `InMemory`.
+    /// Append data. Works for both in-memory and on-disk storage.
     ///
-    /// # Panics
-    /// Panics if storage has been spilled to disk. Callers must ensure data
-    /// is not appended after a spill (in practice, spilling only happens
-    /// for completed/idle flows).
+    /// When in-memory, appends to the `Vec`. When on-disk, appends to the
+    /// temporary file and updates the tracked length.
     pub fn extend_from_slice(&mut self, data: &[u8]) {
         match self {
             Self::InMemory(v) => v.extend_from_slice(data),
-            Self::OnDisk { .. } => {
-                panic!("cannot extend spilled storage; data already on disk");
+            Self::OnDisk { file, len } => {
+                file.write_all(data)
+                    .expect("failed to append to spill file");
+                file.flush().expect("failed to flush spill file");
+                *len += data.len();
             },
         }
     }
@@ -258,6 +259,22 @@ mod tests {
         assert!(s.is_empty());
     }
 
+    #[test]
+    fn test_reassembly_storage_extend_after_spill() {
+        let mut s = ReassemblyStorage::new();
+        s.extend_from_slice(b"hello ");
+        s.spill_to_disk(None).unwrap();
+        assert!(s.is_spilled());
+
+        // Appending after spill should work (writes to file)
+        s.extend_from_slice(b"world");
+        assert_eq!(s.len(), 11);
+        assert!(s.is_spilled());
+
+        let data = s.read_all().unwrap();
+        assert_eq!(data, b"hello world");
+    }
+
     #[test]
     fn test_reassembly_storage_drain_spilled() {
         let mut s = ReassemblyStorage::new();

{stackforge-0.6.1 → stackforge-0.6.2}/crates/stackforge-core/src/flow/table.rs

@@ -125,17 +125,21 @@ impl ConversationTable {
         // Update conversation status from protocol state
         conv.update_status();
 
-        // Track memory for TCP reassembly buffers
+        // Track memory for TCP reassembly buffers (only for in-memory data)
         if self.memory_tracker.has_budget() {
-            if matches!(conv.protocol_state, ProtocolState::Tcp(_)) {
-                // Track bytes that TCP payload may have added
-                let tcp_payload_len = packet.tcp().map_or(0, |tcp| {
-                    let data_offset = tcp.data_offset(buf).unwrap_or(5) as usize * 4;
-                    let payload_start = tcp.index.start + data_offset;
-                    buf.len().saturating_sub(payload_start)
-                });
-                if tcp_payload_len > 0 {
-                    self.memory_tracker.add(tcp_payload_len);
+            if let ProtocolState::Tcp(ref tcp_state) = conv.protocol_state {
+                // Only track if at least one reassembler is still in memory
+                let fwd_spilled = tcp_state.reassembler_fwd.is_spilled();
+                let rev_spilled = tcp_state.reassembler_rev.is_spilled();
+                if !fwd_spilled || !rev_spilled {
+                    let tcp_payload_len = packet.tcp().map_or(0, |tcp| {
+                        let data_offset = tcp.data_offset(buf).unwrap_or(5) as usize * 4;
+                        let payload_start = tcp.index.start + data_offset;
+                        buf.len().saturating_sub(payload_start)
+                    });
+                    if tcp_payload_len > 0 {
+                        self.memory_tracker.add(tcp_payload_len);
+                    }
                 }
             }
         }