feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s

This commit is contained in:
BuTzZ
2026-11-12 22:06:25 +01:00
commit 6c3203d725
194 changed files with 49234 additions and 0 deletions
+73
View File
@@ -0,0 +1,73 @@
use anyhow::{Context, Result, ensure};
use futures_util::{SinkExt, StreamExt};
use prost::Message;
use rmm_protocol::Envelope;
use rustls::{ClientConfig, RootCertStore};
use std::{io::BufReader, net::SocketAddr, sync::Arc, time::Duration};
use tokio::{net::TcpStream, time::timeout};
use tokio_tungstenite::{
Connector, MaybeTlsStream, WebSocketStream,
tungstenite::{Message as WsMessage, protocol::WebSocketConfig},
};
pub type Channel = WebSocketStream<MaybeTlsStream<TcpStream>>;
pub async fn connect(
address: SocketAddr,
ca: &[u8],
certificate: &[u8],
private_key: &[u8],
) -> Result<Channel> {
ensure!(
address.port() != 0 && !address.ip().is_unspecified() && !address.ip().is_multicast(),
"INVALID_CONNECT_ADDRESS"
);
let mut roots = RootCertStore::empty();
for cert in rustls_pemfile::certs(&mut BufReader::new(ca)) {
roots.add(cert?)?;
}
let certs = rustls_pemfile::certs(&mut BufReader::new(certificate))
.collect::<std::io::Result<Vec<_>>>()?;
let key = rustls_pemfile::private_key(&mut BufReader::new(private_key))?
.context("device key missing")?;
let config = ClientConfig::builder()
.with_root_certificates(roots)
.with_client_auth_cert(certs, key)?;
let tcp = timeout(Duration::from_secs(10), TcpStream::connect(address)).await??;
let ws = WebSocketConfig::default()
.max_message_size(Some(rmm_domain::MAX_MESSAGE))
.max_frame_size(Some(rmm_domain::MAX_MESSAGE));
// URL controls TLS SNI and hostname validation; address overrides TCP only.
let (channel, _) = timeout(
Duration::from_secs(10),
tokio_tungstenite::client_async_tls_with_config(
format!("wss://rmm-dev.internal:{}/agent/v1/connect", address.port()),
tcp,
Some(ws),
Some(Connector::Rustls(Arc::new(config))),
),
)
.await??;
Ok(channel)
}
pub async fn send(ws: &mut Channel, e: &Envelope) -> Result<()> {
timeout(
Duration::from_secs(10),
ws.send(WsMessage::Binary(e.encode_to_vec().into())),
)
.await??;
Ok(())
}
pub async fn receive_live(ws: &mut Channel) -> Result<Envelope> {
loop {
match ws.next().await.context("channel closed")?? {
WsMessage::Binary(bytes) => {
ensure!(bytes.len() <= rmm_domain::MAX_MESSAGE, "message limit");
return Ok(Envelope::decode(bytes)?);
}
WsMessage::Ping(_) => ws.flush().await?,
WsMessage::Pong(_) => {}
WsMessage::Close(_) => anyhow::bail!("channel closed"),
_ => anyhow::bail!("binary envelope required"),
}
}
}