hatter/simple-rust-http3-proxy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: v0.3.0 use quinn, now works

Browse Source
This commit is contained in:
Hatter Jiang
2022-08-25 23:05:00 +08:00
parent bec4467b54
commit 04ad8ab668
5 changed files with 176 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
src/server.rs
View File

@@ -1,6 +1,12 @@
use std::fs;
use std::net::SocketAddr;
use std::sync::Arc;
use std::time::Duration;
use futures_util::StreamExt;
use quinn::{Endpoint, ServerConfig};
use rust_util::XResult;
use tokio::time::sleep;
use crate::config::ListenConfig;
use crate::io_util;
@@ -13,31 +19,71 @@ pub async fn run(listen_config: &ListenConfig) -> XResult<()> {
let key_pem = opt_result!(fs::read_to_string(&key_pem_file),
"Read key pem file :{}, failed: {}", &key_pem_file);
// let mut server = Server::builder()
// .with_tls((cert_pem.as_str(), key_pem.as_str()))?
// .with_io(listen_config.listen.as_str())?
// .start()?;
information!("Listen: {}", &listen_config.listen);
// while let Some(mut connection) = server.accept().await {
// // spawn a new task for the connection
// let proxy_address = listen_config.proxy_address.clone();
// tokio::spawn(async move {
// information!("Connection accepted from {:?}", connection.remote_addr());
// while let Ok(Some(stream)) = connection.accept_bidirectional_stream().await {
// // spawn a new task for the stream
// let connection_id = connection.id();
// let proxy_address = proxy_address.clone();
// tokio::spawn(async move {
// information!("Stream opened from {:?}", stream.connection().remote_addr());
// let conn_count = format!("{}-{}-{}", rust_util::util_time::get_current_millis(), connection_id, stream.id());
// if let Err(e) = io_util::transfer_for_server_to_remote(stream, proxy_address, conn_count).await {
// failure!("Server - Client error: {}", e);
// }
// });
// }
// println!("Connection closed from {:?}", connection.remote_addr());
// });
// }
let cert_bytes = opt_result!(pem::parse(&cert_pem), "Parse cert pem failed: {}").contents;
let key_bytes = opt_result!(pem::parse(&key_pem), "Parse key pem failed: {}").contents;
Ok(())
let priv_key = rustls::PrivateKey(key_bytes);
let cert_chain = vec![rustls::Certificate(cert_bytes)];
let mut server_config = opt_result!(ServerConfig::with_single_cert(cert_chain, priv_key), "Create server config failed: {}");
Arc::get_mut(&mut server_config.transport)
.unwrap()
.max_concurrent_uni_streams(0_u8.into());
information!("Listen: {}", &listen_config.listen);
let listen_addr: SocketAddr = opt_result!(listen_config.listen.parse(), "Parse listen address: {} failed: {}", &listen_config.listen);
let (_endpoint, mut incoming) = opt_result!(Endpoint::server(server_config, listen_addr), "Listen server failed: {}");
let proxy_address = listen_config.proxy_address.clone();
loop {
let connection = match incoming.next().await {
Some(connection) => connection,
None => {
warning!("Create connection is None");
sleep(Duration::from_secs(3)).await;
continue;
}
};
let connection = match connection.await {
Ok(connection) => connection,
Err(e) => {
warning!("Create connection failed: {}", e);
sleep(Duration::from_secs(3)).await;
continue;
}
};
let quinn::NewConnection {
connection,
mut bi_streams,
..
} = connection;
let proxy_address = proxy_address.clone();
tokio::spawn(async move {
information!("Connection accepted from {}", connection.remote_address());
let remote_addr = format!("{}", connection.remote_address());
let local_addr = connection.local_ip().map(|ip| format!("{}", ip)).unwrap_or_else(|| "".to_string());
loop {
match bi_streams.next().await {
None => {
information!("Connection ended");
break;
}
Some(Err(e)) => {
information!("Connection ended: {}", e);
break;
}
Some(Ok((send, recv))) => {
let remote_addr = remote_addr.clone();
let local_addr = local_addr.clone();
let proxy_address = proxy_address.clone();
tokio::spawn(async move {
information!("Stream opened from {:?}", &remote_addr);
let conn_count = format!("{}", rust_util::util_time::get_current_millis());
if let Err(e) = io_util::transfer_for_server_to_remote(recv, send, &remote_addr, &local_addr, proxy_address, conn_count).await {
failure!("Server - Client error: {}", e);
}
});
}
}
}
});
}
}