79 lines
2.5 KiB
Rust
79 lines
2.5 KiB
Rust
use crate::client::{AppHandle, ClientEvent};
|
|
use quinn::{crypto::rustls::QuicClientConfig, rustls::pki_types::CertificateDer};
|
|
use std::{
|
|
fs,
|
|
io::ErrorKind,
|
|
net::{IpAddr, Ipv6Addr, SocketAddr},
|
|
str::FromStr,
|
|
sync::Arc,
|
|
};
|
|
use tokio::sync::mpsc::UnboundedSender;
|
|
|
|
pub fn connect(handle: AppHandle, ip: String) {
|
|
std::thread::spawn(|| {
|
|
connect_the(handle, ip).unwrap();
|
|
});
|
|
}
|
|
|
|
pub enum NetCmd {
|
|
SendMsg(String),
|
|
}
|
|
|
|
pub type NetSender = UnboundedSender<NetCmd>;
|
|
|
|
#[tokio::main]
|
|
async fn connect_the(handle: AppHandle, ip: String) -> anyhow::Result<()> {
|
|
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 =
|
|
quinn::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);
|
|
let remote = SocketAddr::from_str(&ip).unwrap();
|
|
// let remote = SocketAddr::new(IpAddr::V6(Ipv6Addr::LOCALHOST), 4433);
|
|
let host = "localhost";
|
|
let conn = endpoint
|
|
.connect(remote, host)?
|
|
.await
|
|
.map_err(|e| anyhow::anyhow!("failed to connect: {}", e))?;
|
|
|
|
let (client_send, mut client_recv) = tokio::sync::mpsc::unbounded_channel::<NetCmd>();
|
|
|
|
handle.send(ClientEvent::Connect(client_send));
|
|
|
|
while let Some(msg) = client_recv.recv().await {
|
|
match msg {
|
|
NetCmd::SendMsg(content) => {
|
|
let (mut send, recv) = conn
|
|
.open_bi()
|
|
.await
|
|
.map_err(|e| anyhow::anyhow!("failed to open stream: {}", e))?;
|
|
|
|
drop(recv);
|
|
|
|
send.write_all(content.as_bytes())
|
|
.await
|
|
.expect("failed to send");
|
|
send.finish().unwrap();
|
|
send.stopped().await.unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|