133 lines
4.0 KiB
Rust
133 lines
4.0 KiB
Rust
use futures_util::StreamExt;
|
|
use tracing::{
|
|
debug,
|
|
error,
|
|
info,
|
|
warn,
|
|
};
|
|
|
|
use quinn_utils::*;
|
|
|
|
#[tokio::main]
|
|
async fn main () -> anyhow::Result <()> {
|
|
tracing_subscriber::fmt::init ();
|
|
|
|
let server_addr = "0.0.0.0:5000".parse ()?;
|
|
let (mut incoming, server_cert) = make_server_endpoint (server_addr)?;
|
|
tokio::fs::write ("quic_server.crt", &server_cert).await?;
|
|
|
|
debug! ("Waiting for end server to connect");
|
|
|
|
let end_server_conn = incoming.next ().await.ok_or_else (|| anyhow::anyhow! ("No end server connection"))?;
|
|
|
|
let end_server_conn = end_server_conn.await?;
|
|
|
|
let quinn::NewConnection {
|
|
connection: end_server_conn,
|
|
..
|
|
} = end_server_conn;
|
|
|
|
debug! ("Waiting for client to connect");
|
|
|
|
let client_conn = incoming.next ().await.ok_or_else (|| anyhow::anyhow! ("No client connection"))?;
|
|
|
|
let client_conn = client_conn.await?;
|
|
|
|
let quinn::NewConnection {
|
|
connection: _client_conn,
|
|
bi_streams: mut client_incoming_bi_streams,
|
|
..
|
|
} = client_conn;
|
|
|
|
debug! ("Waiting for client to open bi stream");
|
|
|
|
let (mut client_send, mut client_recv) = client_incoming_bi_streams.next ().await.ok_or_else (|| anyhow::anyhow! ("Client didn't open a bi stream"))??;
|
|
|
|
debug! ("Opening bi stream to the end server");
|
|
|
|
let (mut server_send, mut server_recv) = end_server_conn.open_bi ().await?;
|
|
|
|
debug! ("Relaying bytes...");
|
|
|
|
// Remember to swap tx and rx for patch cables
|
|
|
|
let uplink_task = tokio::spawn (async move {
|
|
// Uplink - Client to end server
|
|
|
|
let mut buf = vec! [0u8; 65_536];
|
|
while let Some (bytes_read) = client_recv.read (&mut buf).await? {
|
|
let buf_slice = &buf [0..bytes_read];
|
|
server_send.write (buf_slice).await?;
|
|
}
|
|
|
|
debug! ("Uplink closed");
|
|
|
|
Ok::<_, anyhow::Error> (())
|
|
});
|
|
|
|
let downlink_task = tokio::spawn (async move {
|
|
// Downlink - End server to client
|
|
|
|
let mut buf = vec! [0u8; 65_536];
|
|
while let Some (bytes_read) = server_recv.read (&mut buf).await? {
|
|
let buf_slice = &buf [0..bytes_read];
|
|
client_send.write (buf_slice).await?;
|
|
}
|
|
|
|
debug! ("Downlink closed");
|
|
|
|
Ok::<_, anyhow::Error> (())
|
|
});
|
|
|
|
uplink_task.await??;
|
|
downlink_task.await??;
|
|
|
|
Ok (())
|
|
}
|
|
|
|
// I'm not sure where I got this module from, but it's probably from the
|
|
// quinn examples, so the license should be okay.
|
|
|
|
mod quinn_utils {
|
|
use quinn::{
|
|
Certificate, CertificateChain, ClientConfig, ClientConfigBuilder, Endpoint, Incoming,
|
|
PrivateKey, ServerConfig, ServerConfigBuilder, TransportConfig,
|
|
};
|
|
use std::{error::Error, net::SocketAddr, sync::Arc};
|
|
|
|
/// Constructs a QUIC endpoint configured to listen for incoming connections
|
|
/// on a certain address and port.
|
|
///
|
|
/// ## Returns
|
|
///
|
|
/// - a stream of incoming QUIC connections
|
|
/// - server certificate serialized into DER format
|
|
#[allow(unused)]
|
|
pub fn make_server_endpoint(bind_addr: SocketAddr) -> anyhow::Result<(Incoming, Vec<u8>)> {
|
|
let (server_config, server_cert) = configure_server()?;
|
|
let mut endpoint_builder = Endpoint::builder();
|
|
endpoint_builder.listen(server_config);
|
|
let (_endpoint, incoming) = endpoint_builder.bind(&bind_addr)?;
|
|
Ok((incoming, server_cert))
|
|
}
|
|
|
|
/// Returns default server configuration along with its certificate.
|
|
#[allow(clippy::field_reassign_with_default)] // https://github.com/rust-lang/rust-clippy/issues/6527
|
|
fn configure_server() -> anyhow::Result<(ServerConfig, Vec<u8>)> {
|
|
let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
|
|
let cert_der = cert.serialize_der().unwrap();
|
|
let priv_key = cert.serialize_private_key_der();
|
|
let priv_key = PrivateKey::from_der(&priv_key)?;
|
|
|
|
let mut transport_config = TransportConfig::default();
|
|
transport_config.max_concurrent_uni_streams(0).unwrap();
|
|
let mut server_config = ServerConfig::default();
|
|
server_config.transport = Arc::new(transport_config);
|
|
let mut cfg_builder = ServerConfigBuilder::new(server_config);
|
|
let cert = Certificate::from_der(&cert_der)?;
|
|
cfg_builder.certificate(CertificateChain::from_certs(vec![cert]), priv_key)?;
|
|
|
|
Ok((cfg_builder.build(), cert_der))
|
|
}
|
|
}
|