78 lines
2.1 KiB
Rust
78 lines
2.1 KiB
Rust
use std::net::TcpStream;
|
|
use std::io::prelude::*;
|
|
use std::thread;
|
|
use std::sync::{Arc, Mutex, RwLock};
|
|
|
|
use crate::protocol;
|
|
pub mod guard;
|
|
|
|
pub struct Client<'a>{
|
|
client: Arc<Mutex<TcpStream>>,
|
|
server:Arc<Mutex<TcpStream>>,
|
|
hs: protocol::HandShake<'a>,
|
|
run : Arc<RwLock<bool>>,
|
|
}
|
|
|
|
impl<'a> Client<'a> {
|
|
pub fn new(client: TcpStream, server: TcpStream, handshake: protocol::HandShake) -> Client{
|
|
Client {
|
|
client: Arc::new(Mutex::new(client)),
|
|
server: Arc::new(Mutex::new(server)),
|
|
hs: handshake,
|
|
run: Arc::new(RwLock::new(true)),
|
|
//threads: None,
|
|
}
|
|
}
|
|
|
|
pub fn to_string(&self){
|
|
println!("len_pack {}", self.hs.get_host_name());
|
|
}
|
|
|
|
fn join_conexions_mutex(c1: Arc<Mutex<TcpStream>>,
|
|
c2: Arc<Mutex<TcpStream>>,
|
|
run: Arc<RwLock<bool>>){
|
|
let mut buf: [u8; 100000] = [0; 100000];
|
|
let mut client = c1.lock().unwrap().try_clone().unwrap();
|
|
while *run.read().unwrap() {
|
|
let res=client.read(&mut buf);
|
|
match res {
|
|
Ok(leng) => {
|
|
if leng == 0 {
|
|
*run.write().unwrap()=false;
|
|
}
|
|
match c2.lock().unwrap().write(&buf [.. leng]) {
|
|
Ok(_l) => {},
|
|
Err(_e) => *run.write().unwrap()=false,
|
|
}
|
|
},
|
|
|
|
Err(_e) => *run.write().unwrap()=false,
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
pub fn start_proxy(&self) -> (thread::JoinHandle<()>, thread::JoinHandle<()>) {
|
|
|
|
let c1 = self.client.clone();
|
|
let s1 = self.server.clone();
|
|
let r1 = self.run.clone();
|
|
let handler1 = thread::spawn( || {
|
|
Self::join_conexions_mutex(s1,
|
|
c1,
|
|
r1)}
|
|
);
|
|
|
|
let c2 = self.client.clone();
|
|
let s2 = self.server.clone();
|
|
let r2 = self.run.clone();
|
|
let handler2 = thread::spawn( || {
|
|
Self::join_conexions_mutex(c2,
|
|
s2,
|
|
r2)}
|
|
);
|
|
|
|
return (handler1, handler2);
|
|
}
|
|
}
|