75 lines
1.7 KiB
Rust
75 lines
1.7 KiB
Rust
use crate::prelude::*;
|
|
|
|
pub struct NewConnection {
|
|
pub local_send: tokio::net::tcp::OwnedWriteHalf,
|
|
pub local_recv: tokio::net::tcp::OwnedReadHalf,
|
|
pub relay_send: quinn::SendStream,
|
|
pub relay_recv: quinn::RecvStream,
|
|
}
|
|
|
|
pub struct Connection {
|
|
// Blue and green because they're not necessarily uplink nor downlink.
|
|
// It depends on whether the client or server is using us.
|
|
|
|
task_blue: JoinHandle <anyhow::Result <()>>,
|
|
task_green: JoinHandle <anyhow::Result <()>>,
|
|
}
|
|
|
|
impl NewConnection {
|
|
pub fn build (self) -> Connection {
|
|
let Self {
|
|
mut local_send,
|
|
mut local_recv,
|
|
mut relay_send,
|
|
mut relay_recv,
|
|
} = self;
|
|
|
|
let task_blue = tokio::spawn (async move {
|
|
// Downlink - Relay server to local client
|
|
|
|
let mut buf = vec! [0u8; 65_536];
|
|
while let Some (bytes_read) = relay_recv.read (&mut buf).await? {
|
|
let buf_slice = &buf [0..bytes_read];
|
|
trace! ("Uplink relaying {} bytes", bytes_read);
|
|
local_send.write_all (buf_slice).await?;
|
|
}
|
|
|
|
trace! ("Downlink closed");
|
|
|
|
Ok::<_, anyhow::Error> (())
|
|
});
|
|
|
|
let task_green = tokio::spawn (async move {
|
|
// Uplink - local client to relay server
|
|
|
|
let mut buf = vec! [0u8; 65_536];
|
|
loop {
|
|
let bytes_read = local_recv.read (&mut buf).await?;
|
|
if bytes_read == 0 {
|
|
break;
|
|
}
|
|
let buf_slice = &buf [0..bytes_read];
|
|
trace! ("Downlink relaying {} bytes", bytes_read);
|
|
relay_send.write_all (buf_slice).await?;
|
|
}
|
|
|
|
trace! ("Uplink closed");
|
|
|
|
Ok::<_, anyhow::Error> (())
|
|
});
|
|
|
|
Connection {
|
|
task_blue,
|
|
task_green,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Connection {
|
|
pub async fn wait_for_close (self) -> anyhow::Result <()> {
|
|
self.task_blue.await??;
|
|
self.task_green.await??;
|
|
Ok (())
|
|
}
|
|
}
|