cleaned up code, condensed code and fixed a couple of things

src/rmc/response.rs

@@ -49,7 +49,7 @@ pub fn generate_response(protocol_id: u8, response: RMCResponseResult) -> io::Re
     let u32_size: u32 = size as _;
 
     data_out.write_all(bytes_of(&u32_size))?;
-    data_out.push(protocol_id | 0x80);
+    data_out.push(protocol_id);
 
     match response{
         RMCResponseResult::Success {
@@ -59,7 +59,8 @@ pub fn generate_response(protocol_id: u8, response: RMCResponseResult) -> io::Re
         } => {
             data_out.push(1);
             data_out.write_all(bytes_of(&call_id))?;
-            data_out.write_all(bytes_of(&method_id))?;
+            let ored_method_id = method_id | 0x8000;
+            data_out.write_all(bytes_of(&ored_method_id))?;
             data_out.write_all(&data)?;
         },
         RMCResponseResult::Error {
@@ -81,8 +82,6 @@ pub async fn send_response(original_packet: &PRUDPPacket, socket: &SocketData, c
 
     let ConnectionData{
         active_connection_data,
-        sock_addr,
-        server_signature,
         ..
     } = connection;
 
@@ -90,15 +89,12 @@ pub async fn send_response(original_packet: &PRUDPPacket, socket: &SocketData, c
         return;
     };
 
-
     let mut packet = original_packet.base_response_packet();
 
 
     packet.header.types_and_flags.set_types(DATA);
-    packet.header.types_and_flags.set_flag(RELIABLE | HAS_SIZE | NEED_ACK);
+    packet.header.types_and_flags.set_flag((original_packet.header.types_and_flags.get_flags() & RELIABLE) | NEED_ACK);
 
-    packet.header.sequence_id = active_connection.reliable_server_counter;
-    active_connection.reliable_server_counter += 1;
     packet.header.session_id = active_connection.server_session_id;
     packet.header.substream_id = 0;
 
@@ -106,18 +102,7 @@ pub async fn send_response(original_packet: &PRUDPPacket, socket: &SocketData, c
 
     packet.payload = rmcresponse.to_data();
 
-
-    active_connection.server_encryption.apply_keystream(&mut packet.payload);
-
-    packet.set_sizes();
-    packet.calculate_and_assign_signature(socket.access_key, None, Some(*server_signature));
-
-    let mut vec = Vec::new();
-
-    packet.write_to(&mut vec).expect("somehow failed to convert backet to bytes");
-
-    socket.socket.send_to(&vec, sock_addr.regular_socket_addr).await.expect("failed to send data back");
-
+    connection.finish_and_send_packet_to(socket, packet).await;
 }
 
 //taken from kinnays error list directly

src/rmc/structures/any.rs

@@ -1,6 +1,6 @@
-use std::io::{Read, Seek};
+use std::io::{Read, Seek, Write};
 use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
-use super::{string, Result};
+use super::{string, Result, RmcSerialize};
 
 #[derive(Debug)]
 pub struct Any{
@@ -8,21 +8,26 @@ pub struct Any{
     pub data: Vec<u8>
 }
 
-pub fn read(reader: &mut (impl Read + Seek)) -> Result<Any>{
-    let name = string::read(reader)?;
+impl RmcSerialize for Any{
+    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+        todo!()
+    }
+    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+        let name = String::deserialize(reader)?;
 
-    // also length ?
-    let len2: u32 = reader.read_struct(IS_BIG_ENDIAN)?;
-    let length: u32 = reader.read_struct(IS_BIG_ENDIAN)?;
+        // also length ?
+        let len2: u32 = reader.read_struct(IS_BIG_ENDIAN)?;
+        let length: u32 = reader.read_struct(IS_BIG_ENDIAN)?;
 
-    let mut data = vec![0; length as usize];
+        let mut data = vec![0; length as usize];
 
-    reader.read_exact(&mut data)?;
+        reader.read_exact(&mut data)?;
 
-    Ok(
-        Any{
-            name,
-            data
-        }
-    )
+        Ok(
+            Any{
+                name,
+                data
+            }
+        )
+    }
 }

src/rmc/structures/mod.rs

@@ -1,6 +1,8 @@
 use std::io;
+use std::io::{Read, Seek, Write};
 use std::str::Utf8Error;
 use std::string::FromUtf8Error;
+use md5::digest::impl_oid_carrier;
 use thiserror::Error;
 
 //ideas for the future: make a proc macro library which allows generation of struct reads
@@ -16,4 +18,9 @@ pub enum Error{
 type Result<T> = std::result::Result<T, Error>;
 
 pub mod string;
-pub mod any;
+pub mod any;
+
+pub trait RmcSerialize: Sized{
+    fn serialize(&self, writer: &mut dyn Write) -> Result<()>;
+    fn deserialize(reader: &mut dyn Read) -> Result<Self>;
+}

src/rmc/structures/string.rs

@@ -1,18 +1,30 @@
 use std::ffi::CString;
-use std::io::{Read, Seek};
+use std::io::{Read, Seek, Write};
+use bytemuck::bytes_of;
 use log::error;
 use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
-use super::Result;
+use super::{Result, RmcSerialize};
 
-pub fn read(reader: &mut (impl Read + Seek)) -> Result<String>{
-    let len: u16 = reader.read_struct(IS_BIG_ENDIAN)?;
-    let mut data = vec![0; len as usize - 1];
-    reader.read_exact(&mut data)?;
+impl RmcSerialize for String{
+    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+        let len: u16 = reader.read_struct(IS_BIG_ENDIAN)?;
+        let mut data = vec![0; len as usize - 1];
+        reader.read_exact(&mut data)?;
 
-    let null: u8 = reader.read_struct(IS_BIG_ENDIAN)?;
-    if null != 0{
-        error!("unable to find null terminator... continuing anyways");
+        let null: u8 = reader.read_struct(IS_BIG_ENDIAN)?;
+        if null != 0{
+            error!("unable to find null terminator... continuing anyways");
+        }
+
+        Ok(String::from_utf8(data)?)
     }
+    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+        let u16_len: u16 = self.len() as u16;
+        writer.write(bytes_of(&u16_len))?;
 
-    Ok(String::from_utf8(data)?)
+        writer.write(self.as_bytes())?;
+        writer.write(&[0])?;
+
+        Ok(())
+    }
 }