Added the R701 struct

README.md

@@ -1,2 +1,6 @@
-# R701
+# R701 🦀
+
+> A reverse-engineered library to communicate with the [R701 by I.P.S.
+> Informatica](https://ipsattendant.it/rilevatore-presenze-r701/) via TCP,
+> written in Rust
 

src/lib.rs

@@ -0,0 +1,145 @@
+use std::io::{BufRead, BufReader, Error, ErrorKind::InvalidData, Result, Write};
+use std::net::{TcpStream, ToSocketAddrs};
+
+#[derive(Debug)]
+pub struct R701 {
+    tcp_stream: TcpStream,
+    sequence_number: u16,
+}
+
+impl R701 {
+    pub fn connect(connection_info: impl ToSocketAddrs) -> Result<Self> {
+        // Create a new R701 struct
+        let mut new = Self {
+            tcp_stream: TcpStream::connect(connection_info)?,
+            sequence_number: 0,
+        };
+
+        // Try to ping the endpoint
+        new.ping()?;
+        Ok(new)
+    }
+
+    pub fn request(&mut self, payload: &[u8; 12]) -> Result<Vec<u8>> {
+        // Create a blank request
+        let mut request = [0x55, 0xaa, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        // Insert the payload
+        request[2..14].clone_from_slice(payload);
+
+        // Insert the sequence number
+        request[14..].clone_from_slice(&self.sequence_number.to_le_bytes());
+        self.sequence_number += 1;
+
+        // Send the request
+        self.tcp_stream.write_all(&request)?;
+
+        // Create a buffer and return the response
+        let mut buffer = BufReader::new(&self.tcp_stream);
+        Ok(buffer.fill_buf()?.to_vec())
+    }
+
+    pub fn ping(&mut self) -> Result<()> {
+        // Create a request with a payload of `01 80 00 00 00 00 00 00 00 00 00
+        // 00` and get the response
+        let response = self.request(&[0x01, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])?;
+
+        // If the response is not `aa 55 01 01 00 00 00 00 00 00` then return an
+        // error
+        if response != [0xaa, 0x55, 0x01, 0x01, 0, 0, 0, 0, 0, 0] {
+            return Err(Error::new(InvalidData, "Malformed response"));
+        }
+
+        Ok(())
+    }
+
+    pub fn get_name(&mut self, id: u32) -> Result<Option<String>> {
+        // Create a request with a payload of `01 c7 xx xx xx xx 00 00 00 00 14
+        // 00`, where `xx xx xx xx` is the employee ID in little endian
+        let mut request = [0x01, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0x14, 0];
+        request[2..6].clone_from_slice(&id.to_le_bytes());
+
+        // Get the response
+        let response = self.request(&request)?;
+
+        // If the response lenght is right but the header is `01 00 00 00 00 00
+        // 00 00` then the request is been succesful but the name was not found
+        if response[..12] == [0xaa, 0x55, 0x01, 0, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
+            && response.len() == 34
+        {
+            return Ok(None);
+        }
+
+        // If one between the response length or the response header is wrong
+        // return an error
+        if response[..12] != [0xaa, 0x55, 0x01, 0x01, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
+            || response.len() != 34
+        {
+            return Err(Error::new(InvalidData, "Malformed response"));
+        }
+
+        // Get the name as a UTF-8 string and delete the `\0` at the end
+        Ok(Some(
+            String::from_utf8_lossy(&response[12..22])
+                .trim_end_matches(char::from(0))
+                .to_string(),
+        ))
+    }
+
+    pub fn get_total_record_count(&mut self) -> Result<u16> {
+        // Create a request with a payload of `01 b4 08 00 00 00 00 00 ff ff 00
+        // 00` and get the response
+        let response = self.request(&[0x01, 0xb4, 0x08, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 0])?;
+
+        // If one between the response length or the response header is wrong
+        // return an error
+        if response[..4] != [0xaa, 0x55, 0x01, 0x01]
+            || response[6..] != [0u8; 4]
+            || response.len() != 10
+        {
+            return Err(Error::new(InvalidData, "Malformed response"));
+        }
+
+        // Convert the payload into a u16 and return it
+        let mut record_count_le = [0u8; 2];
+        record_count_le.clone_from_slice(&response[4..6]);
+        Ok(u16::from_le_bytes(record_count_le))
+    }
+
+    pub fn get_record_bytes(
+        &mut self,
+        total_records: u16,
+        sequence_number: u16,
+    ) -> Result<Vec<u8>> {
+        // Create a request with a payload of `01 a4 00 00 00 00 xx xx xx xx 00
+        // 04`, where `xx xx xx xx` changes meaning based on the sequence_number
+        // value
+        let mut request: [u8; 12] = [0x01, 0xa4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x04];
+
+        // If sequence_number is 0 then `xx xx xx xx` is `xx xx 00 00`, where
+        // `xx xx` is total_records in little endian
+        //
+        // Else `xx xx xx xx` is `00 00 xx xx`, where `xx xx` is sequence_number
+        // in little endian
+        if sequence_number == 0 {
+            request[6..8].clone_from_slice(&total_records.to_le_bytes());
+        } else {
+            request[8..10].clone_from_slice(&sequence_number.to_le_bytes());
+        }
+
+        // Get the response
+        let response = self.request(&request)?;
+
+        // If one between the response length, the response header or the last
+        // two bits is wrong return an error
+        if response[..12] != [0xaa, 0x55, 0x01, 0x01, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
+            || response[1036..] != [0, 0]
+            || response.len() != 1038
+        {
+            return Err(Error::new(InvalidData, "Malformed response"));
+        }
+
+        // Return only the payload bits as a vector
+        Ok(response[12..response.len() - 2].to_vec())
+    }
+}

src/main.rs

@@ -1,3 +1,5 @@
+use r701::R701;
+
 fn main() {
-    println!("Hello, world!");
+    let _r701 = R701::connect("127.0.0.1:5005").unwrap();
 }