feat(client): protocol v2 wire layer, screen sharing, channel webhooks and secure voice

Verified against the real gateway via tests/gateway_interop.rs.
This commit is contained in:
Loki 2026-10-24 16:51:15 +02:00
parent 8460fb28fd
commit 3d7dd5413b
Signed by: boba
GPG key ID: 253067914055423B
65 changed files with 6048 additions and 1156 deletions

View file

@ -1,18 +1,18 @@
use std::time::Duration;
use anyhow::Result;
use tokio::net::TcpStream;
use anyhow::{Context, Result};
use tokio::sync::mpsc;
use tokio::time::{MissedTickBehavior, interval};
use tracing::warn;
use crate::identity::Identity;
use crate::net::wire;
use crate::net::{
framing, handshake, internal,
payloads::*,
types::{NetCommand, NetEvent},
};
use serde_json;
use super::super::switch::ReconnectRequested;
use super::{VoiceState, handle_cmd};
@ -25,11 +25,22 @@ pub async fn session_loop(
cmd_rx: &mut mpsc::Receiver<NetCommand>,
event_tx: &mpsc::Sender<NetEvent>,
) -> Result<()> {
let mut stream = TcpStream::connect(address).await?;
let connection = tokio::time::timeout(
Duration::from_secs(10),
crate::net::transport::connect_with_peer(address),
)
.await
.context("gateway connection timed out")??;
let peer = connection.peer;
let mut stream = connection.stream;
let mut seq = 0u32;
let (session_id, node_name, private_mode, crypto) =
handshake::run(&mut stream, identity, &mut seq).await?;
let (session_id, node_name, private_mode, crypto) = tokio::time::timeout(
Duration::from_secs(10),
handshake::run(&mut stream, identity, &mut seq),
)
.await
.context("gateway handshake timed out")??;
let _ = event_tx
.send(NetEvent::Connected {
session_id: session_id.clone(),
@ -44,31 +55,58 @@ pub async fn session_loop(
&mut stream,
PID_JOIN_CHANNEL,
&mut seq,
&serde_json::to_vec(&JoinChannelPayload { channel_id })?,
&wire::encode(&JoinChannelPayload { channel_id })?,
&crypto,
)
.await?;
}
let mut voice_state = VoiceState::new(&crypto, event_tx).await?;
let (reader, mut stream) = tokio::io::split(stream);
let mut incoming = framing::io::Reader::new(reader, crypto.clone());
let mut voice_state: Option<VoiceState> = None;
let mut used_voice_routes = std::collections::HashSet::new();
let mut voice_endpoint: Option<std::net::SocketAddr> = None;
let mut voice_tick = interval(Duration::from_secs(5));
voice_tick.set_missed_tick_behavior(MissedTickBehavior::Delay);
let mut ping_tick = interval(Duration::from_secs(2));
ping_tick.set_missed_tick_behavior(MissedTickBehavior::Delay);
loop {
tokio::select! {
_ = voice_tick.tick() => { if let Some(voice)=voice_state.as_mut() {voice.keep_alive().await?;} }
_ = ping_tick.tick() => {
let ts = now_ms();
let payload = serde_json::to_vec(&PingPayload { timestamp: ts })?;
let payload = wire::encode(&PingPayload { timestamp: ts })?;
framing::io::write_encrypted(&mut stream, PID_PING, &mut seq, &payload, &crypto).await?;
}
result = framing::io::read_encrypted(&mut stream, &crypto) => {
result = incoming.next() => {
let pkt = result?;
if pkt.packet_id == PID_VOICE_SESSION {
let session:wire::VoiceSession=wire::decode(&pkt.payload)?;
anyhow::ensure!(session.route_id.len()==16 && session.c2s_key.len()==32 && session.s2c_key.len()==32,"invalid voice credentials");
anyhow::ensure!(used_voice_routes.len()<1024 && used_voice_routes.insert(session.route_id.clone()),"voice credentials must be fresh; reconnect required");
let mut voice=VoiceState::new(event_tx,peer.is_ipv6()).await?;
if let Some(endpoint)=voice_endpoint {voice.set_endpoint(endpoint).await?;}
voice.configure(session).await?;
voice_state=Some(voice);continue;
}
if pkt.packet_id == PID_VOICE_STATE {
let state:wire::VoiceState=wire::decode(&pkt.payload)?;
if state.state=="disconnected" && state.user_id==identity.pubkey_hex {
if voice_state.as_ref().and_then(|value|value.channel_id())==Some(state.channel_id.as_str()) {voice_state=None;voice_endpoint=None;}
channels.retain(|id|id!=&state.channel_id);
let _=event_tx.send(NetEvent::VoiceRevoked {channel_id:state.channel_id}).await;
}
continue;
}
if pkt.packet_id == PID_CHANNEL_STATE
&& let Ok(p) = serde_json::from_slice::<ChannelStatePayload>(&pkt.payload)
&& !p.voice_endpoint.is_empty()
&& let Ok(p) = wire::decode::<ChannelStatePayload>(&pkt.payload)
&& p.kind == "voice" && !p.voice_endpoint.is_empty()
{
voice_endpoint = p.voice_endpoint.parse().ok();
let mut endpoint:std::net::SocketAddr=p.voice_endpoint.parse()?;
if endpoint.ip().is_unspecified() {endpoint.set_ip(peer.ip());}
voice_endpoint=Some(endpoint);
if let Some(voice)=voice_state.as_mut(){voice.set_endpoint(endpoint).await?;}
}
internal::dispatch::incoming(pkt.packet_id, &pkt.payload, event_tx).await?;
}
@ -76,7 +114,7 @@ pub async fn session_loop(
match cmd {
None | Some(NetCommand::Disconnect) => {
let _ = framing::io::write_encrypted(&mut stream, PID_DISCONNECT, &mut seq,
&serde_json::to_vec(&serde_json::json!({"reason":"bye"})).unwrap(), &crypto).await;
&wire::encode(&Disconnect {reason: "bye".into()})?, &crypto).await;
return Ok(());
}
Some(NetCommand::Connect { address, auto_reconnect }) => {
@ -92,15 +130,16 @@ pub async fn session_loop(
Some(NetCommand::JoinChannel { channel_id }) => {
track_channel(channels, &channel_id);
framing::io::write_encrypted(&mut stream, PID_JOIN_CHANNEL, &mut seq,
&serde_json::to_vec(&JoinChannelPayload { channel_id })?, &crypto).await?;
&wire::encode(&JoinChannelPayload { channel_id })?, &crypto).await?;
}
Some(NetCommand::LeaveChannel { channel_id }) => {
channels.retain(|c| c != &channel_id);
if voice_state.as_ref().and_then(|value|value.channel_id())==Some(channel_id.as_str()) {voice_state=None;voice_endpoint=None;}
framing::io::write_encrypted(&mut stream, PID_LEAVE_CHANNEL, &mut seq,
&serde_json::to_vec(&LeaveChannelPayload { channel_id })?, &crypto).await?;
&wire::encode(&LeaveChannelPayload { channel_id })?, &crypto).await?;
}
Some(NetCommand::ChannelCreate { channel_id, channel_name, kind, guild_id }) => {
let payload = serde_json::to_vec(&ChannelCreatePayload {
let payload = wire::encode(&ChannelCreatePayload {
channel_id,
channel_name,
kind,
@ -109,11 +148,11 @@ pub async fn session_loop(
framing::io::write_encrypted(&mut stream, PID_CHANNEL_CREATE, &mut seq, &payload, &crypto).await?;
}
Some(NetCommand::ChannelDelete { channel_id }) => {
let payload = serde_json::to_vec(&ChannelDeletePayload { channel_id })?;
let payload = wire::encode(&ChannelDeletePayload { channel_id })?;
framing::io::write_encrypted(&mut stream, PID_CHANNEL_DELETE, &mut seq, &payload, &crypto).await?;
}
Some(NetCommand::ChannelList) => {
framing::io::write_encrypted(&mut stream, PID_CHANNEL_LIST, &mut seq, b"{}", &crypto).await?;
framing::io::write_encrypted(&mut stream, PID_CHANNEL_LIST, &mut seq, b"", &crypto).await?;
}
Some(NetCommand::SendChat { channel_id, content, reply_to }) => {
let msg = ChatMessagePayload {
@ -123,20 +162,13 @@ pub async fn session_loop(
edited: false,
reply_to,
};
framing::io::write_encrypted(&mut stream, PID_CHAT_MESSAGE, &mut seq, &serde_json::to_vec(&msg)?, &crypto).await?;
framing::io::write_encrypted(&mut stream, PID_CHAT_MESSAGE, &mut seq, &wire::encode(&msg)?, &crypto).await?;
}
Some(NetCommand::SendVoice { channel_id, voice_seq: voice_pkt_seq, timestamp, opus_data }) => {
let sender_pubkey = identity.verifying_key()
.map(|k| k.to_bytes())
.unwrap_or([0u8; 32]);
voice_state.send_voice(channel_id, voice_pkt_seq, timestamp, &opus_data, &crypto, voice_endpoint, &sender_pubkey).await?;
if let Some(voice)=voice_state.as_mut(){voice.send(Some(channel_id), voice_pkt_seq, timestamp, &opus_data).await?;}
}
Some(NetCommand::ReadReceipt { channel_id, last_read_message_id }) => {
let payload = serde_json::to_vec(&serde_json::json!({
"channel_id": channel_id,
"last_read_message_id": last_read_message_id,
"user_id": identity.pubkey_hex.clone(),
}))?;
let payload = wire::encode(&ReadReceipt {channel_id,last_read_message_id,user_id: identity.pubkey_hex.clone()})?;
framing::io::write_encrypted(&mut stream, PID_READ_RECEIPT, &mut seq, &payload, &crypto).await?;
}
Some(other) => handle_cmd(other, &mut stream, &mut seq, &crypto, identity).await?,