90 lines
3.8 KiB
Rust
90 lines
3.8 KiB
Rust
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;
|
|
|
|
pub async fn run(listen_config: &ListenConfig) -> XResult<()> {
|
|
let cert_pem = opt_result!(fs::read_to_string(&listen_config.cert_pem_file),
|
|
"Read cert pem file: {}, failed: {}", &listen_config.cert_pem_file);
|
|
let key_pem_file = opt_value_result!(&listen_config.key_pem_file,
|
|
"key_pem_file in config is required in server mode");
|
|
let key_pem = opt_result!(fs::read_to_string(&key_pem_file),
|
|
"Read key pem file :{}, failed: {}", &key_pem_file);
|
|
|
|
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;
|
|
|
|
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);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|