feat(auth): finish protocol 10 method 2 and 3

src/rmc/message.rs

@@ -58,4 +58,12 @@ impl RMCMessage{
             error_code
         }
     }
+
+    pub fn success_with_data(&self, data: Vec<u8>) -> RMCResponseResult{
+        RMCResponseResult::Success {
+            call_id: self.call_id,
+            method_id: self.method_id,
+            data
+        }
+    }
 }

src/rmc/response.rs

@@ -8,6 +8,8 @@ use crate::prudp::packet::PacketOption::FragmentId;
 use crate::prudp::packet::types::DATA;
 use crate::prudp::socket::{ConnectionData, SocketData};
 
+
+
 pub enum RMCResponseResult {
     Success{
         call_id: u32,
@@ -389,6 +391,7 @@ mod test{
     use hmac::digest::consts::U5;
     use hmac::digest::KeyInit;
     use rc4::{Rc4, StreamCipher};
+    use crate::rmc::response::ErrorCode;
 
     #[test]
     fn test(){
@@ -410,4 +413,10 @@ mod test{
         assert_eq!(data_orig, data);
 
     }
+
+    #[test]
+    fn test_enum_equivilance(){
+        let val: u32 = ErrorCode::Core_Unknown.into();
+        assert_eq!(val, 0x00010001)
+    }
 }

src/rmc/structures/buffer.rs

@@ -0,0 +1,44 @@
+use std::io::{Read, Write};
+use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
+use crate::rmc::structures::RmcSerialize;
+
+impl<'a> RmcSerialize for &'a [u8]{
+    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+        let u32_size = self.len() as u32;
+        writer.write(bytemuck::bytes_of(&u32_size))?;
+        writer.write(self)?;
+
+        Ok(())
+    }
+
+    /// DO NOT USE (also maybe split off the serialize and deserialize functions at some point)
+    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+        panic!("cannot deserialize to a u8 slice reference (use this ONLY for writing)")
+    }
+}
+
+impl<'a> RmcSerialize for Vec<u8>{
+    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+        (&self[..]).serialize(writer)
+    }
+
+    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+        let len: u32 = reader.read_struct(IS_BIG_ENDIAN)?;
+
+        let mut data = vec![0; len as usize];
+
+        reader.read_exact(&mut data)?;
+
+        Ok(data)
+    }
+}
+
+impl<'a> RmcSerialize for Box<[u8]>{
+    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+        (&self[..]).serialize(writer)
+    }
+
+    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+        Vec::deserialize(reader).map(|v| v.into_boxed_slice())
+    }
+}

src/rmc/structures/connection_data.rs

@@ -0,0 +1,27 @@
+use std::io::{Read, Write};
+use bytemuck::bytes_of;
+use crate::kerberos::KerberosDateTime;
+use crate::rmc::structures::{rmc_struct, RmcSerialize};
+
+pub struct ConnectionData<'a>{
+    pub station_url: &'a str,
+    pub special_protocols: Vec<u8>,
+    pub special_station_url: &'a str,
+    pub date_time: KerberosDateTime
+}
+
+impl<'a> RmcSerialize for ConnectionData<'a>{
+    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+        rmc_struct::write_struct(writer, 1, |mut v|{
+            self.station_url.serialize(v).expect("unable to write station url");
+            self.special_protocols.serialize(v).expect("unable to write special protocols");
+            self.special_station_url.serialize(v).expect("unable to write special station url");
+            v.write_all(bytes_of(&self.date_time)).expect("unable to write date time");
+        })
+    }
+
+    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+        todo!()
+    }
+}
+

src/rmc/structures/list.rs

@@ -0,0 +1,21 @@
+use std::io::{Read, Write};
+use bytemuck::bytes_of;
+use crate::rmc::structures::RmcSerialize;
+
+
+impl<T: RmcSerialize> RmcSerialize for Vec<T>{
+    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+        let u32_len = self.len();
+
+        writer.write_all(bytes_of(&u32_len))?;
+        for e in self{
+            e.serialize(writer)?;
+        }
+
+        Ok(())
+    }
+
+    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+        todo!()
+    }
+}

src/rmc/structures/mod.rs

@@ -17,6 +17,11 @@ type Result<T> = std::result::Result<T, Error>;
 
 pub mod string;
 pub mod any;
+pub mod qresult;
+pub mod buffer;
+pub mod connection_data;
+pub mod rmc_struct;
+pub mod list;
 
 pub trait RmcSerialize: Sized{
     fn serialize(&self, writer: &mut dyn Write) -> Result<()>;

src/rmc/structures/qresult.rs

@@ -0,0 +1,37 @@
+use std::io::{Read, Write};
+use bytemuck::{bytes_of, Pod, Zeroable};
+use v_byte_macros::SwapEndian;
+use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
+use crate::rmc::response::ErrorCode;
+use crate::rmc::structures::{RmcSerialize, Result};
+
+const ERROR_MASK: u32 =  1 << 31;
+
+#[derive(Pod, Zeroable, Copy, Clone, SwapEndian)]
+#[repr(transparent)]
+pub struct QResult(u32);
+
+impl QResult{
+    pub fn success(error_code: ErrorCode) -> Self{
+        let val: u32 = error_code.into();
+
+        Self(val & (!ERROR_MASK))
+    }
+
+    pub fn error(error_code: ErrorCode) -> Self{
+        let val: u32 = error_code.into();
+
+        Self(val | ERROR_MASK)
+    }
+}
+
+impl RmcSerialize for QResult{
+    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+        writer.write(bytes_of(self))?;
+        Ok(())
+    }
+
+    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+        Ok(reader.read_struct(IS_BIG_ENDIAN)?)
+    }
+}

src/rmc/structures/rmc_struct.rs

@@ -0,0 +1,24 @@
+use std::io::Write;
+use bytemuck::bytes_of;
+use crate::rmc::structures::Result;
+
+#[repr(C, packed)]
+struct StructureHeader{
+    version: u8,
+    length: u32
+}
+
+pub fn write_struct(mut writer: &mut dyn Write, version: u8, pred: impl Fn(&mut Vec<u8>)) -> Result<()> {
+    writer.write_all(&[version])?;
+
+    let mut scratch_space: Vec<u8> = Vec::new();
+
+    (pred)(&mut scratch_space);
+
+    let u32_size= scratch_space.len() as u32;
+
+    writer.write_all(bytes_of(&u32_size))?;
+    writer.write_all(&scratch_space)?;
+
+    Ok(())
+}

src/rmc/structures/string.rs

@@ -17,6 +17,15 @@ impl RmcSerialize for String{
 
         Ok(String::from_utf8(data)?)
     }
+    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+        (&self[..]).serialize(writer)
+    }
+}
+
+impl RmcSerialize for &str{
+    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+        panic!("cannot serialize to &str")
+    }
     fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
         let u16_len: u16 = self.len() as u16;
         writer.write(bytes_of(&u16_len))?;