git.r.bdr.sh - rbdr/olden-mail/blob - src/proxy.rs

   1 use native_tls::TlsConnector;
   2 use std::io::{Read, Write};
   3 use std::net::{TcpListener, TcpStream};
   4 use std::sync::Arc;
   5 use std::thread::{spawn, JoinHandle};
   6
   7 use crate::configuration::ProxyConfiguration;
   8
   9 pub fn create_proxy(configuration: Arc<ProxyConfiguration>) -> JoinHandle<()> {
  10     let cloned_configuration = Arc::clone(&configuration);
  11     spawn(move || {
  12         run_proxy(cloned_configuration);
  13     })
  14 }
  15
  16 fn run_proxy(configuration: Arc<ProxyConfiguration>) {
  17     let listener = TcpListener::bind(format!("0.0.0.0:{}", configuration.local_port)).unwrap();
  18
  19     println!("Proxy listening on port {}", configuration.local_port);
  20
  21     for stream in listener.incoming() {
  22         match stream {
  23             Ok(stream) => {
  24                 let cloned_configuration = Arc::clone(&configuration);
  25                 spawn(move || {
  26                     handle_client(stream, cloned_configuration);
  27                 });
  28             }
  29             Err(e) => {
  30                 eprintln!("Failed to accept connection: {}", e);
  31             }
  32         }
  33     }
  34 }
  35
  36 fn handle_client(mut client_stream: TcpStream, configuration: Arc<ProxyConfiguration>) {
  37     let connector = TlsConnector::new().unwrap();
  38     let remote_stream = TcpStream::connect(format!(
  39         "{}:{}",
  40         configuration.remote_domain, configuration.remote_port
  41     ))
  42     .unwrap();
  43     let mut remote_stream = connector
  44         .connect(&configuration.remote_domain, remote_stream)
  45         .unwrap();
  46
  47     let mut client_stream_clone = client_stream.try_clone().unwrap();
  48     let mut remote_stream_clone = remote_stream.get_ref().try_clone().unwrap();
  49
  50     let cloned_configuration = Arc::clone(&configuration);
  51     spawn(move || {
  52         forward_stream(&mut client_stream, &mut remote_stream, cloned_configuration);
  53     });
  54     forward_stream(
  55         &mut remote_stream_clone,
  56         &mut client_stream_clone,
  57         configuration,
  58     );
  59 }
  60
  61 fn forward_stream<R: Read, W: Write>(
  62     from: &mut R,
  63     to: &mut W,
  64     configuration: Arc<ProxyConfiguration>,
  65 ) {
  66     let mut buffer = [0; 4096];
  67     loop {
  68         match from.read(&mut buffer) {
  69             Ok(0) => break, // EOF
  70             Ok(n) => {
  71                 if let Err(e) = to.write_all(&buffer[..n]) {
  72                     eprintln!("{} proxy write error: {}", configuration.protocol, e);
  73                     break;
  74                 }
  75                 if let Err(e) = to.flush() {
  76                     eprintln!("{} proxy flush error: {}", configuration.protocol, e);
  77                     break;
  78                 }
  79             }
  80             Err(e) => {
  81                 eprintln!("{} proxy read error: {}", configuration.protocol, e);
  82                 break;
  83             }
  84         }
  85     }
  86 }