🚧 P3 can now tell apart P2 and P4 peers

prototypes/quic_demo/src/bin/quic_demo_client.rs

@@ -27,7 +27,6 @@ async fn main () -> anyhow::Result <()> {
 	let mut resp_buf = [0u8, 0, 0, 0];
 	recv.read_exact (&mut resp_buf).await?;
 	
-	if false {
 	debug! ("Waiting for local TCP client to connect to us");
 	
 	let listener = TcpListener::bind ("127.0.0.1:30381").await?;
@@ -36,8 +35,16 @@ async fn main () -> anyhow::Result <()> {
 	
 	debug! ("Connecting to end server");
 	
-		let (mut relay_send, mut relay_recv) = connection.open_bi ().await?;
+	let (mut send, mut recv) = connection.open_bi ().await?;
 	
+	let req_buf = [1, 43, 0, 0, 1, 0, 0, 0];
+	send.write_all (&req_buf).await?;
+	
+	let mut resp_buf = [0; 8];
+	recv.read_exact (&mut resp_buf).await?;
+	
+	/*
+	if false {
 		debug! ("Relaying bytes...");
 		
 		let uplink_task = tokio::spawn (async move {
@@ -72,6 +79,6 @@ async fn main () -> anyhow::Result <()> {
 		uplink_task.await??;
 		downlink_task.await??;
 	}
-	
+	*/
 	Ok (())
 }

prototypes/quic_demo/src/bin/quic_demo_end_server.rs

@@ -26,7 +26,6 @@ async fn main () -> anyhow::Result <()> {
 	let mut resp_buf = [0u8, 0, 0, 0];
 	recv.read_exact (&mut resp_buf).await?;
 	
-	if false {
 	debug! ("Waiting for relay server to forward a bi stream");
 	
 	let (mut relay_send, mut relay_recv) = bi_streams.next ().await.ok_or_else (|| anyhow::anyhow! ("Relay server didn't open a bi stream"))??;
@@ -69,7 +68,6 @@ async fn main () -> anyhow::Result <()> {
 	
 	uplink_task.await??;
 	downlink_task.await??;
-	}
 	
 	Ok (())
 }

prototypes/quic_demo/src/bin/quic_demo_relay_server.rs

@@ -44,15 +44,52 @@ async fn main () -> anyhow::Result <()> {
 			send.write_all (&resp_buf).await?;
 			
 			match peer_type {
-				2 => while let Some (bi_stream) = bi_streams.next ().await {
+				2 => {
+					while let Some (bi_stream) = bi_streams.next ().await {
 						let (mut send, mut recv) = bi_stream?;
 						
-					// Each new 
+						tokio::spawn (async move {
+							let mut req_buf = [0u8; 4];
+							recv.read_exact (&mut req_buf).await?;
+							
+							let cmd_type = req_buf [0];
+							match cmd_type {
+								1 => {
+									let server_id = req_buf [1];
+									
+									debug! ("P2 {} wants to connect to P4 {}", peer_id, server_id);
+								},
+								_ => bail! ("Unknown command type from P2"),
+							}
+							
+							Ok::<_, anyhow::Error> (())
+						});
+					}
+					
+					debug! ("P2 {} disconnected", peer_id);
+				},
+				4 => {
+					let (tx, mut rx) = mpsc::channel (2);
+					
+					let p4_state = P4State {
+						req_channel: tx,
+					};
+					
+					{
+						let mut relay_state = relay_state.lock ().await;
+						relay_state.p4_server_proxies.insert (peer_id, p4_state);
+					}
+					
+					while let Some (req) = rx.recv ().await {
+						debug! ("P4 {} got a request", peer_id);
+					}
+					
+					debug! ("P4 {} disconnected", peer_id);
 				},
-				4 => (),
 				_ => bail! ("Unknown QUIC client type"),
 			}
 			
+			debug! ("Peer {} disconnected", peer_id);
 			Ok::<_, anyhow::Error> (())
 		});
 	}
@@ -107,13 +144,23 @@ async fn main () -> anyhow::Result <()> {
 
 #[derive (Default)]
 struct RelayState {
+	p4_server_proxies: HashMap <u8, P4State>,
+}
 
+struct P4State {
+	req_channel: mpsc::Sender <RequestP2ToP4>,
 }
 
 impl RelayState {
 	
 }
 
+enum RequestP2ToP4 {
+	Connect {
+		
+	},
+}
+
 struct PtthNewConnection {
 	client_send: quinn::SendStream,
 	client_recv: quinn::RecvStream,

prototypes/quic_demo/src/prelude.rs

@@ -1,4 +1,5 @@
 pub use std::{
+	collections::*,
 	sync::Arc,
 	time::Duration,
 };
@@ -10,7 +11,10 @@ pub use tokio::{
 		AsyncReadExt,
 		AsyncWriteExt,
 	},
-	sync::Mutex,
+	sync::{
+		Mutex,
+		mpsc,
+	},
 	task::JoinHandle,
 };
 pub use tracing::{