stackforge 0.4.0__tar.gz → 0.6.0__tar.gz

{stackforge-0.4.0 → stackforge-0.6.0}/Cargo.lock

@@ -1030,7 +1030,7 @@ dependencies = [
 
 [[package]]
 name = "stackforge"
-version = "0.4.0"
+version = "0.6.0"
 dependencies = [
  "pyo3",
  "stackforge-automata",
@@ -1039,7 +1039,7 @@ dependencies = [
 
 [[package]]
 name = "stackforge-automata"
-version = "0.4.0"
+version = "0.6.0"
 dependencies = [
  "bytes",
  "stackforge-core",
@@ -1047,7 +1047,7 @@ dependencies = [
 
 [[package]]
 name = "stackforge-core"
-version = "0.4.0"
+version = "0.6.0"
 dependencies = [
  "aes",
  "aes-gcm",

{stackforge-0.4.0 → stackforge-0.6.0}/Cargo.toml

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

{stackforge-0.4.0 → stackforge-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackforge
-Version: 0.4.0
+Version: 0.6.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
@@ -35,8 +35,8 @@ Project-URL: Repository, https://github.com/LaBackDoor/stackforge
 
 - **Scapy-style API** — Stack layers with `Ether() / IP() / TCP()`, set fields with keyword arguments
 - **High Performance** — Core logic in Rust, zero-copy parsing, copy-on-write mutation
-- **Broad Protocol Support** — Ethernet, ARP, IPv4/IPv6, TCP, UDP, ICMP, ICMPv6, DNS, HTTP/1.x, HTTP/2, QUIC, L2TP, 802.11 (Wi-Fi), 802.15.4 (Zigbee), and custom protocols
-- **Stateful Flow Extraction** — Extract bidirectional conversations from PCAP files with TCP state tracking, stream reassembly, and UDP timeout handling
+- **Broad Protocol Support** — Ethernet, ARP, IPv4/IPv6, TCP, UDP, ICMP/ICMPv6 (with echo correlation), DNS, HTTP/1.x, HTTP/2, QUIC, L2TP, 802.11 (Wi-Fi), 802.15.4 (Zigbee), and custom protocols
+- **Stateful Flow Extraction** — Extract bidirectional conversations from PCAP files with TCP state tracking, stream reassembly, UDP timeout handling, and optional max packet/flow length tracking
 - **PCAP I/O** — Read and write pcap files with `rdpcap()` / `wrpcap()`
 - **Python Bindings** — Seamless integration via PyO3/maturin
 - **Custom Protocols** — Define runtime protocols with `CustomLayer` and typed fields
@@ -327,6 +327,45 @@ config = FlowConfig(
 conversations = extract_flows("capture.pcap", config=config)
 ```
 
+Optional: Track maximum packet sizes during flow extraction:
+
+```python
+config = FlowConfig(
+    track_max_packet_len=True,   # Track max per-direction (forward_max_packet_len, reverse_max_packet_len)
+    track_max_flow_len=True,     # Track overall max (max_flow_len)
+)
+conversations = extract_flows("capture.pcap", config=config)
+
+for conv in conversations:
+    print(f"Max fwd packet: {conv.forward_max_packet_len} bytes")
+    print(f"Max rev packet: {conv.reverse_max_packet_len} bytes")
+    print(f"Max overall: {conv.max_flow_len} bytes")
+```
+
+Disabled by default (zero overhead). Enable only when needed for flow analysis.
+
+#### ICMP and ICMPv6 Flow Tracking
+
+Automatically correlate ICMP echo request/reply pairs and track other ICMP message types:
+
+```python
+conversations = extract_flows("capture.pcap")
+
+for conv in conversations:
+    if conv.protocol == "ICMP" or conv.protocol == "ICMPv6":
+        print(f"ICMP Echo: {conv.src_addr} <-> {conv.dst_addr}")
+        print(f"  Type: {conv.icmp_type}, Code: {conv.icmp_code}")
+        print(f"  Identifier: {conv.icmp_identifier}")
+        print(f"  Requests: {conv.icmp_request_count}, Replies: {conv.icmp_reply_count}")
+        print(f"  Last seq: {conv.icmp_last_seq}")
+```
+
+Features:
+- Echo request/reply pairs correlated via identifier (symmetric src/dst ports)
+- Non-echo message types tracked via (type, code) substitution
+- Properties: `icmp_type`, `icmp_code`, `icmp_identifier`, `icmp_request_count`, `icmp_reply_count`, `icmp_last_seq`
+- Returns `None` for non-ICMP flows
+
 ## Rust Crate
 
 The core library is available as a standalone Rust crate:

{stackforge-0.4.0 → stackforge-0.6.0}/README.md

@@ -11,8 +11,8 @@
 
 - **Scapy-style API** — Stack layers with `Ether() / IP() / TCP()`, set fields with keyword arguments
 - **High Performance** — Core logic in Rust, zero-copy parsing, copy-on-write mutation
-- **Broad Protocol Support** — Ethernet, ARP, IPv4/IPv6, TCP, UDP, ICMP, ICMPv6, DNS, HTTP/1.x, HTTP/2, QUIC, L2TP, 802.11 (Wi-Fi), 802.15.4 (Zigbee), and custom protocols
-- **Stateful Flow Extraction** — Extract bidirectional conversations from PCAP files with TCP state tracking, stream reassembly, and UDP timeout handling
+- **Broad Protocol Support** — Ethernet, ARP, IPv4/IPv6, TCP, UDP, ICMP/ICMPv6 (with echo correlation), DNS, HTTP/1.x, HTTP/2, QUIC, L2TP, 802.11 (Wi-Fi), 802.15.4 (Zigbee), and custom protocols
+- **Stateful Flow Extraction** — Extract bidirectional conversations from PCAP files with TCP state tracking, stream reassembly, UDP timeout handling, and optional max packet/flow length tracking
 - **PCAP I/O** — Read and write pcap files with `rdpcap()` / `wrpcap()`
 - **Python Bindings** — Seamless integration via PyO3/maturin
 - **Custom Protocols** — Define runtime protocols with `CustomLayer` and typed fields
@@ -303,6 +303,45 @@ config = FlowConfig(
 conversations = extract_flows("capture.pcap", config=config)
 ```
 
+Optional: Track maximum packet sizes during flow extraction:
+
+```python
+config = FlowConfig(
+    track_max_packet_len=True,   # Track max per-direction (forward_max_packet_len, reverse_max_packet_len)
+    track_max_flow_len=True,     # Track overall max (max_flow_len)
+)
+conversations = extract_flows("capture.pcap", config=config)
+
+for conv in conversations:
+    print(f"Max fwd packet: {conv.forward_max_packet_len} bytes")
+    print(f"Max rev packet: {conv.reverse_max_packet_len} bytes")
+    print(f"Max overall: {conv.max_flow_len} bytes")
+```
+
+Disabled by default (zero overhead). Enable only when needed for flow analysis.
+
+#### ICMP and ICMPv6 Flow Tracking
+
+Automatically correlate ICMP echo request/reply pairs and track other ICMP message types:
+
+```python
+conversations = extract_flows("capture.pcap")
+
+for conv in conversations:
+    if conv.protocol == "ICMP" or conv.protocol == "ICMPv6":
+        print(f"ICMP Echo: {conv.src_addr} <-> {conv.dst_addr}")
+        print(f"  Type: {conv.icmp_type}, Code: {conv.icmp_code}")
+        print(f"  Identifier: {conv.icmp_identifier}")
+        print(f"  Requests: {conv.icmp_request_count}, Replies: {conv.icmp_reply_count}")
+        print(f"  Last seq: {conv.icmp_last_seq}")
+```
+
+Features:
+- Echo request/reply pairs correlated via identifier (symmetric src/dst ports)
+- Non-echo message types tracked via (type, code) substitution
+- Properties: `icmp_type`, `icmp_code`, `icmp_identifier`, `icmp_request_count`, `icmp_reply_count`, `icmp_last_seq`
+- Returns `None` for non-ICMP flows
+
 ## Rust Crate
 
 The core library is available as a standalone Rust crate:

{stackforge-0.4.0 → stackforge-0.6.0}/crates/stackforge-core/src/flow/config.rs

@@ -20,6 +20,10 @@ pub struct FlowConfig {
     pub max_ooo_fragments: usize,
     /// Interval between idle conversation eviction sweeps (default: 30s).
     pub eviction_interval: Duration,
+    /// Track maximum packet length per direction (default: false).
+    pub track_max_packet_len: bool,
+    /// Track maximum flow length per direction (default: false).
+    pub track_max_flow_len: bool,
 }
 
 impl Default for FlowConfig {
@@ -32,6 +36,8 @@ impl Default for FlowConfig {
             max_reassembly_buffer: 16 * 1024 * 1024, // 16 MB
             max_ooo_fragments: 100,
             eviction_interval: Duration::from_secs(30),
+            track_max_packet_len: false,
+            track_max_flow_len: false,
         }
     }
 }
@@ -50,5 +56,7 @@ mod tests {
         assert_eq!(config.max_reassembly_buffer, 16 * 1024 * 1024);
         assert_eq!(config.max_ooo_fragments, 100);
         assert_eq!(config.eviction_interval, Duration::from_secs(30));
+        assert!(!config.track_max_packet_len);
+        assert!(!config.track_max_flow_len);
     }
 }

stackforge-0.6.0/crates/stackforge-core/src/flow/icmp_state.rs

@@ -0,0 +1,144 @@
+use std::time::Duration;
+
+use crate::Packet;
+
+use super::config::FlowConfig;
+use super::state::ConversationStatus;
+
+/// ICMP/ICMPv6 conversation state.
+///
+/// Tracks ICMP-specific metadata for echo request/reply pairs and other ICMP types.
+/// Echo requests and replies are correlated using the ICMP identifier field.
+#[derive(Debug, Clone)]
+pub struct IcmpFlowState {
+    /// ICMP type (e.g., 8 for Echo Request, 0 for Echo Reply).
+    pub icmp_type: u8,
+    /// ICMP code.
+    pub icmp_code: u8,
+    /// ICMP identifier (for echo, timestamp, and other types that use it).
+    pub identifier: Option<u16>,
+    /// Number of echo requests (type 8 for ICMP, 128 for ICMPv6).
+    pub request_count: u64,
+    /// Number of echo replies (type 0 for ICMP, 129 for ICMPv6).
+    pub reply_count: u64,
+    /// Last sequence number seen in an echo packet.
+    pub last_seq: Option<u16>,
+    /// Conversation status.
+    pub status: ConversationStatus,
+}
+
+impl IcmpFlowState {
+    #[must_use]
+    pub fn new(icmp_type: u8, icmp_code: u8) -> Self {
+        Self {
+            icmp_type,
+            icmp_code,
+            identifier: None,
+            request_count: 0,
+            reply_count: 0,
+            last_seq: None,
+            status: ConversationStatus::Active,
+        }
+    }
+
+    /// Update state when a new ICMP packet is received.
+    ///
+    /// Increments request or reply count based on ICMP type, and updates
+    /// the identifier and sequence number fields if present.
+    pub fn process_packet(&mut self, packet: &Packet, buf: &[u8], icmp_type: u8, icmp_code: u8) {
+        // Update type/code on every packet (they should be consistent)
+        self.icmp_type = icmp_type;
+        self.icmp_code = icmp_code;
+
+        // Get ICMP layer bounds to extract fields
+        if let Some(icmp_layer) = crate::layer::LayerKind::Icmp
+            .try_into()
+            .ok()
+            .and_then(|kind| packet.get_layer(kind))
+        {
+            let icmp_start = icmp_layer.start;
+
+            // Extract identifier (bytes 4-5) if present
+            if buf.len() >= icmp_start + 6 {
+                self.identifier = Some(u16::from_be_bytes([
+                    buf[icmp_start + 4],
+                    buf[icmp_start + 5],
+                ]));
+            }
+
+            // Extract sequence number (bytes 6-7) if present
+            if buf.len() >= icmp_start + 8 {
+                self.last_seq = Some(u16::from_be_bytes([
+                    buf[icmp_start + 6],
+                    buf[icmp_start + 7],
+                ]));
+            }
+
+            // Count requests and replies based on ICMP type
+            match icmp_type {
+                8 => {
+                    // ICMP Echo Request
+                    self.request_count += 1;
+                },
+                0 => {
+                    // ICMP Echo Reply
+                    self.reply_count += 1;
+                },
+                128 => {
+                    // ICMPv6 Echo Request
+                    self.request_count += 1;
+                },
+                129 => {
+                    // ICMPv6 Echo Reply
+                    self.reply_count += 1;
+                },
+                _ => {
+                    // Other ICMP types: no counting
+                },
+            }
+        }
+
+        self.status = ConversationStatus::Active;
+    }
+
+    /// Check whether this flow has timed out.
+    #[must_use]
+    pub fn check_timeout(&self, last_seen: Duration, now: Duration, config: &FlowConfig) -> bool {
+        // ICMP uses UDP timeout
+        now.saturating_sub(last_seen) > config.udp_timeout
+    }
+}
+
+impl Default for IcmpFlowState {
+    fn default() -> Self {
+        Self::new(0, 0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_icmp_state_new() {
+        let state = IcmpFlowState::new(8, 0);
+        assert_eq!(state.icmp_type, 8);
+        assert_eq!(state.icmp_code, 0);
+        assert_eq!(state.request_count, 0);
+        assert_eq!(state.reply_count, 0);
+        assert_eq!(state.identifier, None);
+        assert_eq!(state.last_seq, None);
+    }
+
+    #[test]
+    fn test_icmp_timeout() {
+        let config = FlowConfig::default(); // 120s UDP timeout
+        let state = IcmpFlowState::new(8, 0);
+
+        // Not timed out
+        assert!(!state.check_timeout(Duration::from_secs(100), Duration::from_secs(200), &config));
+
+        // Timed out
+        assert!(state.check_timeout(Duration::from_secs(100), Duration::from_secs(300), &config));
+    }
+}

{stackforge-0.4.0 → stackforge-0.6.0}/crates/stackforge-core/src/flow/key.rs

@@ -291,7 +291,59 @@ pub fn extract_key(packet: &Packet) -> Result<(CanonicalKey, FlowDirection), Flo
                 .map_err(|e| FlowError::PacketError(e.into()))?;
             (sport, dport)
         },
-        // ICMP and other protocols have no ports
+        TransportProtocol::Icmp => {
+            // For ICMP, use identifier (for echo/timestamp types) for both ports
+            // (symmetric), or type+code as port substitute for other types.
+            // Using identifier symmetrically ensures request and reply have
+            // the same canonical key regardless of direction.
+            if let Some(icmp_layer) = packet.get_layer(LayerKind::Icmp) {
+                if buf.len() >= icmp_layer.start + 8 {
+                    let icmp_type = buf[icmp_layer.start];
+                    let is_echo = icmp_type == 0 || icmp_type == 8;
+                    if is_echo {
+                        let id = u16::from_be_bytes([
+                            buf[icmp_layer.start + 4],
+                            buf[icmp_layer.start + 5],
+                        ]);
+                        (id, id) // Use identifier symmetrically for both ports
+                    } else {
+                        let code = buf[icmp_layer.start + 1];
+                        (icmp_type as u16, code as u16)
+                    }
+                } else {
+                    (0u16, 0u16)
+                }
+            } else {
+                (0u16, 0u16)
+            }
+        },
+        TransportProtocol::Icmpv6 => {
+            // For ICMPv6, use identifier (for echo/timestamp types) for both ports
+            // (symmetric), or type+code as port substitute for other types.
+            // Using identifier symmetrically ensures request and reply have
+            // the same canonical key regardless of direction.
+            if let Some(icmpv6_layer) = packet.get_layer(LayerKind::Icmpv6) {
+                if buf.len() >= icmpv6_layer.start + 8 {
+                    let icmpv6_type = buf[icmpv6_layer.start];
+                    let is_echo = icmpv6_type == 128 || icmpv6_type == 129;
+                    if is_echo {
+                        let id = u16::from_be_bytes([
+                            buf[icmpv6_layer.start + 4],
+                            buf[icmpv6_layer.start + 5],
+                        ]);
+                        (id, id) // Use identifier symmetrically for both ports
+                    } else {
+                        let code = buf[icmpv6_layer.start + 1];
+                        (icmpv6_type as u16, code as u16)
+                    }
+                } else {
+                    (0u16, 0u16)
+                }
+            } else {
+                (0u16, 0u16)
+            }
+        },
+        // Other protocols have no ports
         _ => (0u16, 0u16),
     };
 

{stackforge-0.4.0 → stackforge-0.6.0}/crates/stackforge-core/src/flow/mod.rs

@@ -27,6 +27,7 @@
 
 pub mod config;
 pub mod error;
+pub mod icmp_state;
 pub mod key;
 pub mod state;
 pub mod table;
@@ -37,6 +38,7 @@ pub mod udp_state;
 // Re-exports
 pub use config::FlowConfig;
 pub use error::FlowError;
+pub use icmp_state::IcmpFlowState;
 pub use key::{
     CanonicalKey, FlowDirection, TransportProtocol, ZWaveKey, extract_key, extract_zwave_key,
 };
@@ -119,7 +121,7 @@ pub fn extract_zwave_flows(
             state
         });
 
-        conv.record_packet(direction, byte_count, timestamp, index);
+        conv.record_packet(direction, byte_count, timestamp, index, false, false);
 
         // Track ACK vs command frames
         if let ProtocolState::ZWave(ref mut zw) = conv.protocol_state

{stackforge-0.4.0 → stackforge-0.6.0}/crates/stackforge-core/src/flow/state.rs

@@ -1,6 +1,7 @@
 use std::time::Duration;
 
 use super::config::FlowConfig;
+use super::icmp_state::IcmpFlowState;
 use super::key::{CanonicalKey, FlowDirection, TransportProtocol};
 use super::tcp_state::TcpConversationState;
 use super::udp_state::UdpFlowState;
@@ -47,6 +48,8 @@ pub struct DirectionStats {
     pub first_seen: Duration,
     /// Timestamp of the most recent packet in this direction.
     pub last_seen: Duration,
+    /// Maximum packet length in this direction (if tracking enabled).
+    pub max_packet_len: Option<u64>,
 }
 
 impl DirectionStats {
@@ -57,14 +60,18 @@ impl DirectionStats {
             bytes: 0,
             first_seen: timestamp,
             last_seen: timestamp,
+            max_packet_len: None,
         }
     }
 
     /// Record a new packet in this direction.
-    pub fn record_packet(&mut self, byte_count: u64, timestamp: Duration) {
+    pub fn record_packet(&mut self, byte_count: u64, timestamp: Duration, track_max_len: bool) {
         self.packets += 1;
         self.bytes += byte_count;
         self.last_seen = timestamp;
+        if track_max_len {
+            self.max_packet_len = Some(self.max_packet_len.unwrap_or(0).max(byte_count));
+        }
     }
 }
 
@@ -75,9 +82,13 @@ pub enum ProtocolState {
     Tcp(TcpConversationState),
     /// UDP pseudo-conversation with timeout tracking.
     Udp(UdpFlowState),
+    /// ICMP conversation with echo request/reply tracking.
+    Icmp(IcmpFlowState),
+    /// ICMPv6 conversation with echo request/reply tracking.
+    Icmpv6(IcmpFlowState),
     /// Z-Wave wireless conversation with home ID and node tracking.
     ZWave(ZWaveFlowState),
-    /// Other protocols (ICMP, etc.) — no specific state tracking.
+    /// Other protocols — no specific state tracking.
     Other,
 }
 
@@ -115,6 +126,8 @@ pub struct ConversationState {
     pub packet_indices: Vec<usize>,
     /// Protocol-specific state.
     pub protocol_state: ProtocolState,
+    /// Maximum packet length across both directions (if tracking enabled).
+    pub max_flow_len: Option<u64>,
 }
 
 impl ConversationState {
@@ -124,6 +137,8 @@ impl ConversationState {
         let protocol_state = match key.protocol {
             TransportProtocol::Tcp => ProtocolState::Tcp(TcpConversationState::new()),
             TransportProtocol::Udp => ProtocolState::Udp(UdpFlowState::new()),
+            TransportProtocol::Icmp => ProtocolState::Icmp(IcmpFlowState::new(0, 0)),
+            TransportProtocol::Icmpv6 => ProtocolState::Icmpv6(IcmpFlowState::new(0, 0)),
             _ => ProtocolState::Other,
         };
 
@@ -136,6 +151,7 @@ impl ConversationState {
             reverse: DirectionStats::new(timestamp),
             packet_indices: Vec::new(),
             protocol_state,
+            max_flow_len: None,
         }
     }
 
@@ -172,6 +188,7 @@ impl ConversationState {
                 command_count: 0,
                 ack_count: 0,
             }),
+            max_flow_len: None,
         }
     }
 
@@ -200,13 +217,26 @@ impl ConversationState {
         byte_count: u64,
         timestamp: Duration,
         packet_index: usize,
+        track_max_packet_len: bool,
+        track_max_flow_len: bool,
     ) {
         self.last_seen = timestamp;
         self.packet_indices.push(packet_index);
 
         match direction {
-            FlowDirection::Forward => self.forward.record_packet(byte_count, timestamp),
-            FlowDirection::Reverse => self.reverse.record_packet(byte_count, timestamp),
+            FlowDirection::Forward => {
+                self.forward
+                    .record_packet(byte_count, timestamp, track_max_packet_len);
+            },
+            FlowDirection::Reverse => {
+                self.reverse
+                    .record_packet(byte_count, timestamp, track_max_packet_len);
+            },
+        }
+
+        // Update max flow length if tracking is enabled
+        if track_max_flow_len {
+            self.max_flow_len = Some(self.max_flow_len.unwrap_or(0).max(byte_count));
         }
     }
 
@@ -230,6 +260,12 @@ impl ConversationState {
             ProtocolState::Udp(udp) => {
                 self.status = udp.status;
             },
+            ProtocolState::Icmp(icmp) => {
+                self.status = icmp.status;
+            },
+            ProtocolState::Icmpv6(icmpv6) => {
+                self.status = icmpv6.status;
+            },
             ProtocolState::ZWave(_) => {},
             ProtocolState::Other => {},
         }
@@ -250,6 +286,7 @@ impl ConversationState {
                 }
             },
             ProtocolState::Udp(_) => elapsed > config.udp_timeout,
+            ProtocolState::Icmp(_) | ProtocolState::Icmpv6(_) => elapsed > config.udp_timeout,
             ProtocolState::ZWave(_) => elapsed > config.udp_timeout,
             ProtocolState::Other => elapsed > config.udp_timeout,
         }

{stackforge-0.4.0 → stackforge-0.6.0}/crates/stackforge-core/src/flow/table.rs

@@ -72,7 +72,14 @@ impl ConversationTable {
         let conv = entry.value_mut();
 
         // Record packet stats
-        conv.record_packet(direction, byte_count, timestamp, packet_index);
+        conv.record_packet(
+            direction,
+            byte_count,
+            timestamp,
+            packet_index,
+            self.config.track_max_packet_len,
+            self.config.track_max_flow_len,
+        );
 
         // Process protocol-specific state
         let buf = packet.as_bytes();
@@ -85,6 +92,26 @@ impl ConversationTable {
             ProtocolState::Udp(udp_state) => {
                 udp_state.process_packet();
             },
+            ProtocolState::Icmp(icmp_state) => {
+                // Get ICMP type and code from buffer
+                if let Some(icmp_layer) = packet.get_layer(crate::layer::LayerKind::Icmp) {
+                    if buf.len() >= icmp_layer.start + 2 {
+                        let icmp_type = buf[icmp_layer.start];
+                        let icmp_code = buf[icmp_layer.start + 1];
+                        icmp_state.process_packet(packet, buf, icmp_type, icmp_code);
+                    }
+                }
+            },
+            ProtocolState::Icmpv6(icmpv6_state) => {
+                // Get ICMPv6 type and code from buffer
+                if let Some(icmpv6_layer) = packet.get_layer(crate::layer::LayerKind::Icmpv6) {
+                    if buf.len() >= icmpv6_layer.start + 2 {
+                        let icmpv6_type = buf[icmpv6_layer.start];
+                        let icmpv6_code = buf[icmpv6_layer.start + 1];
+                        icmpv6_state.process_packet(packet, buf, icmpv6_type, icmpv6_code);
+                    }
+                }
+            },
             ProtocolState::ZWave(_) => {},
             ProtocolState::Other => {},
         }