1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
// use std::sync::{Arc, Mutex};
// use openssl::ssl::{Ssl, SslConnector, SslFiletype, SslMethod};
// use tokio::net::TcpStream;
// use tokio_openssl::SslStream;
// use crate::{
// client::tcp::handle_client,
// protocol::prelude::common::{
// error::{Error, ErrorKind},
// utils::{Certificate, Listener, DEVICES},
// },
// };
// ///
// /// Listens for incoming TLS connections.
// ///
// /// It creates a new thread for SHDP clients.
// ///
// /// # Arguments
// /// * `port` - The port to listen on.
// /// * `cert` - The certificate to use.
// ///
// /// # Returns
// /// * [Result<(), Error>] - The result of the operation.
// ///
// /// # Errors
// /// Generated errors are related to the I/O operations.<br>
// /// They need to be handled by the caller.
// ///
// /// # Example
// /// ```rust,no_run
// /// use shdp::prelude::client::tls::connect;
// /// use shdp::prelude::common::utils::Certificate;
// ///
// /// #[tokio::main]
// /// async fn main() {
// /// match connect(String::from("157.165.164.160"), String::from("8080"), Certificate {
// /// cert_path: String::from("cert.pem"),
// /// key_path: String::from("key.pem"),
// /// }).await {
// /// Ok(_) => println!("Connected established"),
// /// Err(e) => println!("Error: {:?}", e),
// /// }
// /// }
// /// ```
// pub async fn connect(ip: String, port: String, cert: Certificate) -> Result<(), Error> {
// let connector = load_connector(cert);
// let stream = match TcpStream::connect(format!("{}:{}", ip, port)).await {
// Ok(stream) => stream,
// Err(e) => {
// println!(
// "[SHDP:TLS] Error connecting to {}:{}",
// ip.clone(),
// port.clone()
// );
// return Err(Error {
// code: 0,
// message: e.to_string(),
// kind: ErrorKind::UserDefined(Box::new(e)),
// });
// }
// };
// let static_stream = Arc::new(Mutex::new(stream));
// DEVICES.lock().unwrap().insert(
// (ip.clone(), port.clone()),
// Listener::TokioClient(static_stream),
// );
// let mut devices = DEVICES.lock().unwrap();
// let real_stream = devices
// .get_mut(&(ip.clone(), port.clone()))
// .unwrap()
// .get_tokio_client();
// // let ssl = Ssl::new(connector.context()).unwrap();
// // let mut tls_stream = match SslStream::new(ssl, real_stream.lock().unwrap().) {
// // Ok(tls_stream) => Arc::new(Mutex::new(tls_stream)),
// // Err(e) => {
// // println!("[SHDP:TLS] Error creating TLS stream: {:?}", e);
// // return Err(Error {
// // code: 0,
// // message: e.to_string(),
// // kind: ErrorKind::UserDefined(Box::new(e)),
// // });
// // }
// // };
// // println!("[SHDP:TLS] Connected to {}:{}", ip.clone(), port.clone());
// // let _ = handle_client(tls_stream).await;
// Ok(())
// }
// fn load_connector(cert: Certificate) -> Arc<SslConnector> {
// let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
// builder
// .set_private_key_file(&cert.key_path, SslFiletype::PEM)
// .unwrap();
// builder.set_certificate_chain_file(&cert.cert_path).unwrap();
// Arc::new(builder.build())
// }