feat: add quinn

__network/quinn/src/main.rs

@@ -0,0 +1,46 @@
+use std::net::SocketAddr;
+use quinn::{Incoming, Endpoint, ServerConfig, PrivateKey, TransportConfig, ServerConfigBuilder, Certificate, CertificateChain};
+use std::error::Error;
+use std::sync::Arc;
+use std::str::FromStr;
+use futures_util::StreamExt;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let addr = SocketAddr::from_str("127.0.0.1:8888").unwrap();
+    let (mut incoming, server_cert) = make_server_endpoint(addr)?;
+    // accept a single connection
+    tokio::spawn(async move {
+        let quinn::NewConnection { connection, .. } = incoming.next().await.unwrap().await.unwrap();
+        println!(
+            "[server] incoming connection: addr={}",
+            connection.remote_address()
+        );
+    });
+    Ok(())
+}
+
+
+pub fn make_server_endpoint(bind_addr: SocketAddr) -> Result<(Incoming, Vec<u8>), Box<dyn Error>> {
+    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))
+}
+
+fn configure_server() -> Result<(ServerConfig, Vec<u8>), Box<dyn Error>> {
+    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))
+}