use openssl::ssl::{SslConnector, SslMethod};
use std::io::{ErrorKind, Write};
use std::net::TcpStream;
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
pub fn write_to_server(
server: &str,
port: &str,
rx: mpsc::Receiver<String>,
tx: mpsc::Sender<String>,
) {
'big: loop {
println!("Connecting to {server}:{port}");
let tcp_stream =
TcpStream::connect(format!("{server}:{port}")).expect("Couldn't connect to server");
let connector = SslConnector::builder(SslMethod::tls()).unwrap().build();
let mut stream = connector
.connect(server, &tcp_stream)
.expect("Couldn't start TLS");
stream
.get_mut()
.set_nonblocking(true)
.expect("Failed to set nonblocking");
loop {
let mut buffer: Vec<u8> = Vec::new();
let mut buf: [u8; 1] = [0];
let newline: u8 = b'\n';
while buf[0] != newline {
match stream.ssl_read(&mut buf) {
Ok(_length) => {
if _length > 0 {
buffer.push(buf[0]);
}
}
Err(_error) => match _error.io_error() {
None => {
dbg!(_error.ssl_error());
continue 'big;
}
Some(error) => match error.kind() {
ErrorKind::WouldBlock => {}
_ => {
dbg!(error.kind());
println!("Couldn't read the stream");
continue 'big;
}
},
},
}
let value = rx.try_recv().unwrap_or("".to_string());
match value.as_str() {
"DUMMY CLOSE_CONNECTION" => {
continue 'big;
}
_ => {}
}
match stream.write_all(value.as_bytes()) {
Ok(_) => {}
Err(_e) => println!("Couldn't send {value}"),
};
thread::sleep(Duration::from_micros(100));
}
let _ = tx.send(dbg!(String::from_utf8_lossy(&buffer).to_string()));
}
}
}