add full CIP object access support and extend explicit messaging features

Author: JaskRendix

src/cip/read_write.rs

@@ -163,6 +163,58 @@ pub fn build_read_fragmented_request(
     cip
 }
 
+fn encode_object_path(class_id: u8, instance_id: u8, slot: Option<u8>) -> Vec<u8> {
+    let mut segments = Vec::new();
+
+    if let Some(slot) = slot {
+        segments.extend_from_slice(&[0x01, slot, 0x00, 0x00]);
+    }
+
+    segments.extend_from_slice(&[0x20, class_id, 0x24, instance_id]);
+
+    let word_count = (segments.len() / 2) as u8;
+    let mut out = Vec::with_capacity(1 + segments.len());
+    out.push(word_count);
+    out.extend_from_slice(&segments);
+    out
+}
+
+fn encode_object_attribute_path(
+    class_id: u8,
+    instance_id: u8,
+    attribute_id: u8,
+    slot: Option<u8>,
+) -> Vec<u8> {
+    let mut path = encode_object_path(class_id, instance_id, slot);
+    path.extend_from_slice(&[0x30, attribute_id]);
+    let word_count = ((path.len() - 1) / 2) as u8;
+    path[0] = word_count;
+    path
+}
+
+pub fn build_get_attribute_single_request(
+    class_id: u8,
+    instance_id: u8,
+    attribute_id: u8,
+    slot: Option<u8>,
+) -> Vec<u8> {
+    let path = encode_object_attribute_path(class_id, instance_id, attribute_id, slot);
+
+    let mut cip = Vec::with_capacity(1 + path.len());
+    cip.push(CipService::GetAttributeSingle as u8);
+    cip.extend_from_slice(&path);
+    cip
+}
+
+pub fn build_get_attribute_all_request(class_id: u8, instance_id: u8, slot: Option<u8>) -> Vec<u8> {
+    let path = encode_object_path(class_id, instance_id, slot);
+
+    let mut cip = Vec::with_capacity(1 + path.len());
+    cip.push(CipService::GetAttributeAll as u8);
+    cip.extend_from_slice(&path);
+    cip
+}
+
 fn encode_connection_manager_path(slot: Option<u8>) -> Vec<u8> {
     let mut segments = Vec::new();
 

src/cip/service.rs

@@ -1,5 +1,7 @@
 #[derive(Debug, Copy, Clone)]
 pub enum CipService {
+    GetAttributeAll = 0x01,
+    GetAttributeSingle = 0x0E,
     ReadData = 0x4C,
     WriteData = 0x4D,
     ReadFragmented = 0x52,

src/client/tag_rw.rs

@@ -1,7 +1,8 @@
 use std::io;
 
 use crate::cip::{
-    build_read_request, build_write_request, decode_cip_response, decode_write_response, CipError,
+    build_get_attribute_all_request, build_get_attribute_single_request, build_read_request,
+    build_write_request, decode_cip_response, decode_write_response, CipError,
 };
 use crate::client::{ConnectedMessaging, TagReadWrite, UnconnectedMessaging};
 use crate::types::CipValue;
@@ -20,23 +21,9 @@ impl TagReadWrite for EthernetIpClient {
         };
 
         let res = res.map_err(|_| CipError::VendorSpecific(0xFF))?;
+        let payload = parse_cip_response_payload(&res)?;
 
-        if res.len() < 4 {
-            return Err(CipError::VendorSpecific(0xFE));
-        }
-
-        let general_status = res[2];
-        if general_status != 0 {
-            return Err(CipError::from(general_status));
-        }
-
-        let ext_words = res[3] as usize;
-        let data_start = 4 + ext_words * 2;
-        if res.len() < data_start {
-            return Err(CipError::VendorSpecific(0xFD));
-        }
-
-        decode_cip_response(&res[data_start..]).ok_or(CipError::VendorSpecific(0xFC))
+        decode_cip_response(payload).ok_or(CipError::VendorSpecific(0xFC))
     }
 
     async fn write_tag(&mut self, tag: &str, value: CipValue) -> Result<(), CipError> {
@@ -66,27 +53,56 @@ impl TagReadWrite for EthernetIpClient {
         };
 
         let res = res.map_err(|_| CipError::VendorSpecific(0xFF))?;
+        let payload = parse_cip_response_payload(&res)?;
 
-        if res.len() < 4 {
-            return Err(CipError::VendorSpecific(0xFE));
+        if payload.len() < 2 {
+            return Err(CipError::VendorSpecific(0xFD));
         }
 
-        let general_status = res[2];
-        if general_status != 0 {
-            return Err(CipError::from(general_status));
-        }
+        let type_id = u16::from_le_bytes([payload[0], payload[1]]);
+        let payload = &payload[2..];
 
-        let ext_words = res[3] as usize;
-        let data_start = 4 + ext_words * 2;
+        Ok(crate::cip::decode_cip_data_list(type_id, payload))
+    }
 
-        if res.len() < data_start + 2 {
-            return Err(CipError::VendorSpecific(0xFD));
-        }
+    async fn read_object_attribute(
+        &mut self,
+        class_id: u8,
+        instance_id: u8,
+        attribute_id: u8,
+    ) -> Result<CipValue, CipError> {
+        let cip =
+            build_get_attribute_single_request(class_id, instance_id, attribute_id, self.slot);
 
-        let type_id = u16::from_le_bytes([res[data_start], res[data_start + 1]]);
-        let payload = &res[data_start + 2..];
+        let res: io::Result<Vec<u8>> = if self.connected {
+            self.send_unit_data(cip).await
+        } else {
+            self.send_rr_data(cip).await
+        };
 
-        Ok(crate::cip::decode_cip_data_list(type_id, payload))
+        let res = res.map_err(|_| CipError::VendorSpecific(0xFF))?;
+        let payload = parse_cip_response_payload(&res)?;
+
+        decode_cip_response(payload).ok_or(CipError::VendorSpecific(0xFC))
+    }
+
+    async fn read_object_attributes(
+        &mut self,
+        class_id: u8,
+        instance_id: u8,
+    ) -> Result<Vec<u8>, CipError> {
+        let cip = build_get_attribute_all_request(class_id, instance_id, self.slot);
+
+        let res: io::Result<Vec<u8>> = if self.connected {
+            self.send_unit_data(cip).await
+        } else {
+            self.send_rr_data(cip).await
+        };
+
+        let res = res.map_err(|_| CipError::VendorSpecific(0xFF))?;
+        let payload = parse_cip_response_payload(&res)?;
+
+        Ok(payload.to_vec())
     }
 
     async fn write_tag_multi(&mut self, tag: &str, values: &[CipValue]) -> Result<(), CipError> {
@@ -182,3 +198,22 @@ impl TagReadWrite for EthernetIpClient {
             .await
     }
 }
+
+fn parse_cip_response_payload(res: &[u8]) -> Result<&[u8], CipError> {
+    if res.len() < 4 {
+        return Err(CipError::VendorSpecific(0xFE));
+    }
+
+    let general_status = res[2];
+    if general_status != 0 {
+        return Err(CipError::from(general_status));
+    }
+
+    let ext_words = res[3] as usize;
+    let data_start = 4 + ext_words * 2;
+    if res.len() < data_start {
+        return Err(CipError::VendorSpecific(0xFD));
+    }
+
+    Ok(&res[data_start..])
+}

src/client/traits.rs

@@ -49,6 +49,27 @@ pub trait TagReadWrite {
     async fn read_tag_multi(&mut self, tag: &str, count: usize) -> Result<Vec<CipValue>, CipError>;
     async fn write_tag_multi(&mut self, tag: &str, values: &[CipValue]) -> Result<(), CipError>;
 
+    async fn read_object_attribute(
+        &mut self,
+        class_id: u8,
+        instance_id: u8,
+        attribute_id: u8,
+    ) -> Result<CipValue, CipError>;
+
+    async fn read_object_attributes(
+        &mut self,
+        class_id: u8,
+        instance_id: u8,
+    ) -> Result<Vec<u8>, CipError>;
+
+    async fn read_identity_attribute(&mut self, attribute_id: u8) -> Result<CipValue, CipError> {
+        self.read_object_attribute(0x01, 0x01, attribute_id).await
+    }
+
+    async fn read_identity_attributes(&mut self) -> Result<Vec<u8>, CipError> {
+        self.read_object_attributes(0x01, 0x01).await
+    }
+
     async fn read_bool(&mut self, tag: &str) -> Result<bool, CipError>;
     async fn read_sint(&mut self, tag: &str) -> Result<i8, CipError>;
     async fn read_int(&mut self, tag: &str) -> Result<i16, CipError>;

src/lib.rs

@@ -5,7 +5,8 @@ pub mod fake_plc;
 pub mod types;
 
 pub use cip::{
-    build_cip_multiple_service_request, build_read_request, build_write_request,
+    build_cip_multiple_service_request, build_get_attribute_all_request,
+    build_get_attribute_single_request, build_read_request, build_write_request,
     decode_cip_response, encode_epath, encode_epath_with_slot, parse_cip_multiple_service_response,
     parse_symbol_browse_response, CipError, CipService,
 };

tests/cip_builders.rs

@@ -1,5 +1,6 @@
 use ethernetip::cip::{
-    build_forward_close_request, build_forward_open_request, build_large_forward_close_request,
+    build_forward_close_request, build_forward_open_request, build_get_attribute_all_request,
+    build_get_attribute_single_request, build_large_forward_close_request,
     build_large_forward_open_request, build_read_fragmented_request, build_read_request,
     build_write_request, decode_extended_status, describe_extended_status, map_extended_status,
     service::CipService, ConnectionParams, ForwardOpenError, TransportTrigger,
@@ -62,6 +63,52 @@ fn test_build_read_fragmented_request() {
     assert_eq!(offset, 200);
 }
 
+#[test]
+fn test_build_get_attribute_single_request() {
+    let cip = build_get_attribute_single_request(0x06, 0x01, 0x03, None);
+    assert_eq!(cip[0], CipService::GetAttributeSingle as u8);
+    assert_eq!(cip[1], 3); // word count for class+instance+attribute
+    assert_eq!(cip[2], 0x20);
+    assert_eq!(cip[3], 0x06);
+    assert_eq!(cip[4], 0x24);
+    assert_eq!(cip[5], 0x01);
+    assert_eq!(cip[6], 0x30);
+    assert_eq!(cip[7], 0x03);
+}
+
+#[test]
+fn test_build_get_attribute_single_request_slot() {
+    let cip = build_get_attribute_single_request(0x06, 0x01, 0x03, Some(2));
+    assert_eq!(cip[0], CipService::GetAttributeSingle as u8);
+    assert_eq!(cip[1], 5); // word count for port segment + object path
+    assert_eq!(cip[2], 0x01);
+    assert_eq!(cip[3], 2);
+    assert_eq!(cip[6], 0x20);
+    assert_eq!(cip[7], 0x06);
+}
+
+#[test]
+fn test_build_get_attribute_all_request() {
+    let cip = build_get_attribute_all_request(0x02, 0x01, None);
+    assert_eq!(cip[0], CipService::GetAttributeAll as u8);
+    assert_eq!(cip[1], 2); // word count for class + instance
+    assert_eq!(cip[2], 0x20);
+    assert_eq!(cip[3], 0x02);
+    assert_eq!(cip[4], 0x24);
+    assert_eq!(cip[5], 0x01);
+}
+
+#[test]
+fn test_build_get_attribute_all_request_slot() {
+    let cip = build_get_attribute_all_request(0x02, 0x01, Some(3));
+    assert_eq!(cip[0], CipService::GetAttributeAll as u8);
+    assert_eq!(cip[1], 4); // word count for port segment + class + instance
+    assert_eq!(cip[2], 0x01);
+    assert_eq!(cip[3], 3);
+    assert_eq!(cip[6], 0x20);
+    assert_eq!(cip[7], 0x02);
+}
+
 #[test]
 fn test_forward_open_request_structure() {
     let cip = build_forward_open_request(Some(2), ConnectionParams::default());