feat(data,transfer): implement outbound & inbound, swap roles, add handshake intent

Author: LizAinslie

crates/protocol/src/packet/handshake.rs

@@ -9,26 +9,33 @@ use uuid::Uuid;
 
 use crate::ConnectionType;
 use crate::packet::{DeserializePacket, SerializePacket};
-
+use crate::utils::ConnectionIntent;
 
 pub enum HandshakePacketGuestToHost {
-    // in
+    /// Establish a connection with the other server
     Hello {
         connection_type: ConnectionType,
     },
+
     /// Send my hostname to the other server
     Identify {
         hostname: String,
     },
+
     /// Send the client-decrypted challenge bytes back to the server
     Verify {
         challenge: Vec<u8>,
         nonce: Uuid,
     },
+
+    /// Inform the other server of my intent.
+    SetIntent {
+        intent: ConnectionIntent,
+    }
 }
 
 pub enum HandshakePacketHostToGuest {
-    // out
+    /// Acknowledge the client connection
     Acknowledge {
         ok: bool,
         err: Option<String>,
@@ -39,6 +46,13 @@ pub enum HandshakePacketHostToGuest {
         encrypted_challenge: Vec<u8>,
         nonce: Uuid,
     },
+
+    /// Tell the client whether the challenge was successful
+    ChallengeResponse {
+        successful: bool,
+    },
+
+    /// Close the Handshake frame
     Close {
         can_continue: bool,
         err: Option<String>
@@ -51,6 +65,7 @@ impl From<&HandshakePacketGuestToHost> for u8 {
             HandshakePacketGuestToHost::Hello { .. } => 1,
             HandshakePacketGuestToHost::Identify { .. } => 2,
             HandshakePacketGuestToHost::Verify { .. } => 3,
+            HandshakePacketGuestToHost::SetIntent { .. } => 4,
         }
     }
 }
@@ -60,7 +75,8 @@ impl From<&HandshakePacketHostToGuest> for u8 {
         match pkt {
             HandshakePacketHostToGuest::Acknowledge { .. } => 1,
             HandshakePacketHostToGuest::Challenge { .. } => 2,
-            HandshakePacketHostToGuest::Close { .. } => 3
+            HandshakePacketHostToGuest::Close { .. } => 3,
+            HandshakePacketHostToGuest::ChallengeResponse { .. } => 4,
         }
     }
 }
@@ -72,7 +88,7 @@ impl SerializePacket for HandshakePacketGuestToHost {
         let mut bytes_written: usize = 1;
         match self {
             HandshakePacketGuestToHost::Hello { connection_type } => {
-                buf.put_u8(u8::from(connection_type));
+                buf.put_u8(connection_type.into());
                 bytes_written += 1
             }
             HandshakePacketGuestToHost::Identify { hostname } => {
@@ -85,6 +101,10 @@ impl SerializePacket for HandshakePacketGuestToHost {
                 buf.put_slice(challenge);
                 bytes_written += 256;
             }
+            HandshakePacketGuestToHost::SetIntent { intent } => {
+                buf.put_u8(intent.into());
+                bytes_written += 1;
+            }
         }
         Ok(bytes_written)
     }
@@ -115,6 +135,10 @@ impl SerializePacket for HandshakePacketHostToGuest {
 
                 bytes_written += self.write_optional_string(buf, err);
             }
+            HandshakePacketHostToGuest::ChallengeResponse { successful } => {
+                buf.put_u8(*successful as u8);
+                bytes_written += 1;
+            }
         }
 
         Ok(bytes_written)
@@ -128,7 +152,7 @@ impl DeserializePacket for HandshakePacketGuestToHost {
         // We'll match the same `u8` that is used to recognize which request type this is
         match buf.get_u8() {
             1 => Ok(HandshakePacketGuestToHost::Hello {
-                connection_type: ConnectionType::from_u8(buf.get_u8()),
+                connection_type: ConnectionType::from(buf.get_u8()),
             }),
             2 => Ok(HandshakePacketGuestToHost::Identify {
                 hostname: Self::read_string(buf)?,
@@ -143,6 +167,9 @@ impl DeserializePacket for HandshakePacketGuestToHost {
                     nonce,
                 })
             },
+            4 => Ok(HandshakePacketGuestToHost::SetIntent {
+                intent: ConnectionIntent::from(buf.get_u8()),
+            }),
             _ => Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 "Invalid Request Type",
@@ -174,6 +201,9 @@ impl DeserializePacket for HandshakePacketHostToGuest {
                 can_continue: buf.get_u8() != 0,
                 err: Self::read_optional_string(buf)?,
             }),
+            4 => Ok(HandshakePacketHostToGuest::ChallengeResponse {
+                successful: buf.get_u8() != 0,
+            }),
             _ => Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 "Invalid Request Type",
@@ -184,7 +214,8 @@ impl DeserializePacket for HandshakePacketHostToGuest {
 
 #[cfg(test)]
 mod tests {
-    async fn serialize_handshake_packets() {
+    #[test]
+    async fn serialize_gth_hello() {
 
     }
 }

crates/protocol/src/packet/transfer.rs

@@ -7,13 +7,13 @@ use uuid::Uuid;
 
 use crate::packet::{DeserializePacket, SerializePacket};
 
-pub enum TransferPacketGuestToHost {
+pub enum TransferPacketHostToGuest {
     AcknowledgeObject {
         can_send: bool
     }
 }
 
-pub enum TransferPacketHostToGuest {
+pub enum TransferPacketGuestToHost {
     IdentifyObject {
         data_id: Uuid,
         data_len: usize,
@@ -27,20 +27,20 @@ pub enum TransferPacketHostToGuest {
 
 
 
-impl From<&TransferPacketGuestToHost> for u8 {
-    fn from(pkt: &TransferPacketGuestToHost) -> Self {
+impl From<&TransferPacketHostToGuest> for u8 {
+    fn from(pkt: &TransferPacketHostToGuest) -> Self {
         match pkt {
-            TransferPacketGuestToHost::AcknowledgeObject { .. } => 1
+            TransferPacketHostToGuest::AcknowledgeObject { .. } => 1
         }
     }
 }
 
-impl SerializePacket for TransferPacketGuestToHost {
+impl SerializePacket for TransferPacketHostToGuest {
     fn serialize(&self, buf: &mut BytesMut) -> io::Result<usize> {
         buf.put_u8(self.into());
         let mut bytes_written = 1;
         match self {
-            TransferPacketGuestToHost::AcknowledgeObject { can_send } => {
+            TransferPacketHostToGuest::AcknowledgeObject { can_send } => {
                 buf.put_u8(*can_send as u8);
                 bytes_written += 1;
             }
@@ -50,12 +50,12 @@ impl SerializePacket for TransferPacketGuestToHost {
     }
 }
 
-impl DeserializePacket for TransferPacketGuestToHost {
-    type Output = TransferPacketGuestToHost;
+impl DeserializePacket for TransferPacketHostToGuest {
+    type Output = TransferPacketHostToGuest;
 
     fn deserialize(buf: &mut BytesMut) -> io::Result<Self::Output> {
         match buf.get_u8() {
-            1 => Ok(TransferPacketGuestToHost::AcknowledgeObject {
+            1 => Ok(TransferPacketHostToGuest::AcknowledgeObject {
                 can_send: buf.get_u8() != 0,
             }),
             _ => Err(io::Error::new(
@@ -66,28 +66,28 @@ impl DeserializePacket for TransferPacketGuestToHost {
     }
 }
 
-impl From<&TransferPacketHostToGuest> for u8 {
-    fn from(pkt: &TransferPacketHostToGuest) -> Self {
+impl From<&TransferPacketGuestToHost> for u8 {
+    fn from(pkt: &TransferPacketGuestToHost) -> Self {
         match pkt {
-            TransferPacketHostToGuest::IdentifyObject { .. } => 1,
-            TransferPacketHostToGuest::SendChunk { .. } => 2
+            TransferPacketGuestToHost::IdentifyObject { .. } => 1,
+            TransferPacketGuestToHost::SendChunk { .. } => 2
         }
     }
 }
 
-impl SerializePacket for TransferPacketHostToGuest {
+impl SerializePacket for TransferPacketGuestToHost {
     fn serialize(&self, buf: &mut BytesMut) -> io::Result<usize> {
         buf.put_u8(self.into());
         let mut bytes_written = 1;
 
         match self {
-            TransferPacketHostToGuest::IdentifyObject { data_chunks, data_len, data_id } => {
+            TransferPacketGuestToHost::IdentifyObject { data_chunks, data_len, data_id } => {
                 bytes_written += self.write_uuid(buf, data_id);
                 buf.put_u64(*data_len as u64);
                 buf.put_u64(*data_chunks as u64);
                 bytes_written += 16; // two u64
             }
-            TransferPacketHostToGuest::SendChunk { data, done } => {
+            TransferPacketGuestToHost::SendChunk { data, done } => {
                 buf.put_u64(data.len() as u64);
                 bytes_written += 8;
                 buf.put_slice(data);
@@ -101,12 +101,12 @@ impl SerializePacket for TransferPacketHostToGuest {
     }
 }
 
-impl DeserializePacket for TransferPacketHostToGuest {
-    type Output = TransferPacketHostToGuest;
+impl DeserializePacket for TransferPacketGuestToHost {
+    type Output = TransferPacketGuestToHost;
 
     fn deserialize(buf: &mut BytesMut) -> io::Result<Self::Output> {
         match buf.get_u8() {
-            1 => Ok(TransferPacketHostToGuest::IdentifyObject {
+            1 => Ok(TransferPacketGuestToHost::IdentifyObject {
                 data_id: Self::read_uuid(buf),
                 data_len: buf.get_u64() as usize,
                 data_chunks: buf.get_u64() as usize,
@@ -116,7 +116,7 @@ impl DeserializePacket for TransferPacketHostToGuest {
                 let mut data_buf = vec![0u8; data_len];
                 buf.copy_to_slice(&mut data_buf);
 
-                Ok(TransferPacketHostToGuest::SendChunk {
+                Ok(TransferPacketGuestToHost::SendChunk {
                     data: data_buf,
                     done: buf.get_u8() != 0,
                 })

crates/protocol/src/utils.rs

@@ -1,12 +1,14 @@
-#[derive(Clone)]
+use std::fmt::{Display, Formatter};
+
+#[derive(Clone, PartialEq)]
 pub enum ConnectionType {
     Unknown = 0,
     Client = 1,
     Server = 2
 }
 
-impl ConnectionType {
-    pub(crate) fn from_u8(t: u8) -> ConnectionType {
+impl From<u8> for ConnectionType {
+    fn from(t: u8) -> ConnectionType {
         match t {
             1 => ConnectionType::Client,
             2 => ConnectionType::Server,
@@ -23,4 +25,47 @@ impl From<&ConnectionType> for u8 {
             ConnectionType::Server => 2,
         }
     }
+}
+
+#[derive(Clone, PartialEq)]
+pub enum ConnectionIntent {
+    Subscribe,
+    TransferData,
+    Unknown,
+}
+
+impl From<u8> for ConnectionIntent {
+    fn from(i: u8) -> Self {
+        match i {
+            1 => ConnectionIntent::Subscribe,
+            2 => ConnectionIntent::TransferData,
+            _ => ConnectionIntent::Unknown,
+        }
+    }
+}
+
+impl From<&ConnectionIntent> for u8 {
+    fn from(i: &ConnectionIntent) -> Self {
+        match i {
+            ConnectionIntent::Unknown => 0,
+            ConnectionIntent::Subscribe => 1,
+            ConnectionIntent::TransferData => 2,
+        }
+    }
+}
+
+impl Display for ConnectionIntent {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ConnectionIntent::Subscribe => {
+                write!(f, "subscribe")
+            }
+            ConnectionIntent::TransferData => {
+                write!(f, "transfer-data")
+            }
+            ConnectionIntent::Unknown => {
+                write!(f, "unknown")
+            }
+        }
+    }
 }