more refactor

src/bin/client/net.rs

@@ -0,0 +1,140 @@
+use crate::{AppHandle, ClientEvent};
+use openworm::net::{
+    ClientMsg, RecvHandler, SERVER_NAME, ServerMsg, SkipServerVerification, recv_uni, send_uni,
+};
+use quinn::{
+    ClientConfig, Connection, Endpoint, IdleTimeout, TransportConfig,
+    crypto::rustls::QuicClientConfig,
+};
+use std::{
+    net::{Ipv6Addr, SocketAddr, SocketAddrV6, ToSocketAddrs},
+    sync::Arc,
+    time::Duration,
+};
+use tokio::sync::mpsc::UnboundedSender;
+
+pub const CLIENT_SOCKET: SocketAddr =
+    SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::UNSPECIFIED, 0, 0, 0));
+
+pub struct ConnectInfo {
+    pub ip: String,
+    pub username: String,
+}
+
+pub fn connect(handle: AppHandle, info: ConnectInfo) {
+    std::thread::spawn(move || {
+        if let Err(msg) = connect_the(handle.clone(), info) {
+            handle.send(ClientEvent::Err(msg));
+        }
+    });
+}
+
+type NetResult<T> = Result<T, String>;
+
+type MsgPayload = ClientMsg;
+pub struct NetSender {
+    send: UnboundedSender<MsgPayload>,
+}
+
+impl NetSender {
+    pub fn send(&self, msg: ClientMsg) {
+        let _ = self.send.send(msg);
+    }
+}
+
+// async fn connection_cert(addr: SocketAddr) -> NetResult<Connection> {
+//     let dirs = directories_next::ProjectDirs::from("", "", "openworm").unwrap();
+//     let mut roots = quinn::rustls::RootCertStore::empty();
+//     match fs::read(dirs.data_local_dir().join("cert.der")) {
+//         Ok(cert) => {
+//             roots.add(CertificateDer::from(cert))?;
+//         }
+//         Err(ref e) if e.kind() == ErrorKind::NotFound => {
+//             eprintln!("local server certificate not found");
+//         }
+//         Err(e) => {
+//             eprintln!("failed to open local server certificate: {}", e);
+//         }
+//     }
+//     let client_crypto = quinn::rustls::ClientConfig::builder()
+//         .with_root_certificates(roots)
+//         .with_no_client_auth();
+//     let client_config = ClientConfig::new(Arc::new(QuicClientConfig::try_from(client_crypto)?));
+//     let mut endpoint = quinn::Endpoint::client(SocketAddr::from_str("[::]:0").unwrap())?;
+//     endpoint.set_default_client_config(client_config);
+//     endpoint
+//         .connect(addr, SERVER_NAME)?
+//         .await
+//         .map_err(|e| format!("failed to connect: {}", e))
+// }
+
+async fn connection_no_cert(addr: SocketAddr) -> NetResult<Connection> {
+    let mut endpoint = Endpoint::client(CLIENT_SOCKET).map_err(|e| e.to_string())?;
+
+    let quic = QuicClientConfig::try_from(
+        quinn::rustls::ClientConfig::builder()
+            .dangerous()
+            .with_custom_certificate_verifier(SkipServerVerification::new())
+            .with_no_client_auth(),
+    )
+    .map_err(|e| e.to_string())?;
+
+    let mut config = ClientConfig::new(Arc::new(quic));
+
+    let mut transport = TransportConfig::default();
+    transport.keep_alive_interval(Some(Duration::from_secs(5)));
+    transport.max_idle_timeout(Some(
+        IdleTimeout::try_from(Duration::from_secs(10)).unwrap(),
+    ));
+    config.transport_config(transport.into());
+
+    endpoint.set_default_client_config(config);
+
+    // connect to server
+    endpoint
+        .connect(addr, SERVER_NAME)
+        .map_err(|e| e.to_string())?
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tokio::main]
+async fn connect_the(handle: AppHandle, info: ConnectInfo) -> NetResult<()> {
+    let (send, mut ui_recv) = tokio::sync::mpsc::unbounded_channel::<MsgPayload>();
+
+    let addr = info
+        .ip
+        .to_socket_addrs()
+        .map_err(|e| e.to_string())?
+        .next()
+        .ok_or("no addresses found".to_string())?;
+    let conn = connection_no_cert(addr).await?;
+    let conn_ = conn.clone();
+
+    handle.send(ClientEvent::Connect {
+        username: info.username,
+        send: NetSender { send },
+    });
+
+    let recv = ServerRecv { handle };
+    tokio::spawn(recv_uni(conn_, recv.into()));
+
+    while let Some(msg) = ui_recv.recv().await {
+        if send_uni(&conn, msg).await.is_err() {
+            println!("disconnected from server");
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+struct ServerRecv {
+    handle: AppHandle,
+}
+
+impl RecvHandler<ServerMsg> for ServerRecv {
+    async fn msg(&self, msg: ServerMsg) {
+        self.handle.send(ClientEvent::ServerMsg(msg));
+    }
+}