e2e-irc/src/writer_client.rs

use openssl::ssl::{SslConnector, SslMethod};
use std::io::{ErrorKind, Write};
use std::net::TcpStream;
use std::sync::mpsc;
use std::time::Duration;

pub fn write_to_server(
    tcp_stream: TcpStream,
    server: String,
    rx: mpsc::Receiver<String>,
    tx: mpsc::Sender<String>,
) {
    tcp_stream
        .set_read_timeout(Some(Duration::from_millis(10)))
        .expect("Couldn't set timeout!!");

    let connector = SslConnector::builder(SslMethod::tls()).unwrap().build();
    let mut stream = connector
        .connect(&server, &tcp_stream)
        .expect("Couldn't start TLS");

    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) => {
                    buffer.push(buf[0]);
                }
                Err(_error) => match _error.io_error() {
                    None => {
                        dbg!(_error);
                        panic!("TLS Error")
                    }
                    Some(error) => match error.kind() {
                        ErrorKind::TimedOut => {}
                        ErrorKind::WouldBlock => {}
                        _ => {
                            dbg!(error.kind());
                            println!("Couldn't read the stream");
                        }
                    },
                },
            }

            match rx.try_recv() {
                Ok(value) => {
                    match stream.write_all(value.as_bytes()) {
                        Ok(_) => {}
                        Err(_e) => println!("Couldn't send {value}"),
                    };
                }
                Err(_e) => {}
            }
        }

        let _ = tx.send(String::from_utf8_lossy(&buffer).to_string());
    }
}