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?,

View file

@ -1,60 +1,64 @@
use crate::net::wire;
use anyhow::Result;
use serde_json;
use tokio::net::TcpStream;
use crate::net::{crypto::SessionCrypto, framing, payloads::*, types::NetCommand};
pub async fn handle_cmd(
cmd: NetCommand,
stream: &mut TcpStream,
stream: &mut (impl tokio::io::AsyncWrite + Unpin),
seq: &mut u32,
crypto: &SessionCrypto,
) -> Result<()> {
match cmd {
NetCommand::PresenceUpdate {
status,
custom_status,
custom_status: _,
activity,
activity_text,
} => {
let payload = serde_json::to_vec(&PresenceUpdatePayload {
let payload = wire::encode(&PresenceUpdatePayload {
status,
activity_type: activity,
activity_text,
custom_status,
})?;
framing::io::write_encrypted(stream, PID_PRESENCE_UPDATE, seq, &payload, crypto)
.await?;
}
NetCommand::FriendRequest { target_user_id } => {
let payload = serde_json::to_vec(&FriendRequestPayload { target_user_id })?;
let payload = wire::encode(&FriendRequestPayload {
to_user_id: target_user_id,
})?;
framing::io::write_encrypted(stream, PID_FRIEND_REQUEST, seq, &payload, crypto).await?;
}
NetCommand::FriendAccept { user_id } => {
let payload = serde_json::to_vec(&FriendAcceptPayload { user_id })?;
let payload = wire::encode(&FriendAcceptPayload {
from_user_id: user_id,
})?;
framing::io::write_encrypted(stream, PID_FRIEND_ACCEPT, seq, &payload, crypto).await?;
}
NetCommand::FriendDecline { user_id } => {
let payload = serde_json::to_vec(&FriendDeclinePayload { user_id })?;
let payload = wire::encode(&FriendDeclinePayload {
from_user_id: user_id,
})?;
framing::io::write_encrypted(stream, PID_FRIEND_DECLINE, seq, &payload, crypto).await?;
}
NetCommand::FriendRemove { user_id } => {
let payload = serde_json::to_vec(&FriendRemovePayload { user_id })?;
let payload = wire::encode(&FriendRemovePayload { user_id })?;
framing::io::write_encrypted(stream, PID_FRIEND_REMOVE, seq, &payload, crypto).await?;
}
NetCommand::FriendList => {
framing::io::write_encrypted(stream, PID_FRIEND_LIST, seq, b"{}", crypto).await?;
framing::io::write_encrypted(stream, PID_FRIEND_LIST, seq, b"", crypto).await?;
}
NetCommand::BlockUser { user_id } => {
let payload = serde_json::to_vec(&BlockUserPayload { user_id })?;
let payload = wire::encode(&BlockUserPayload { user_id })?;
framing::io::write_encrypted(stream, PID_BLOCK_USER, seq, &payload, crypto).await?;
}
NetCommand::UnblockUser { user_id } => {
let payload = serde_json::to_vec(&UnblockUserPayload { user_id })?;
let payload = wire::encode(&UnblockUserPayload { user_id })?;
framing::io::write_encrypted(stream, PID_UNBLOCK_USER, seq, &payload, crypto).await?;
}
NetCommand::BlockList => {
framing::io::write_encrypted(stream, PID_BLOCK_LIST, seq, b"{}", crypto).await?;
framing::io::write_encrypted(stream, PID_BLOCK_LIST, seq, b"", crypto).await?;
}
_ => {}
}

View file

@ -1,43 +1,48 @@
use crate::net::wire;
use anyhow::Result;
use serde_json;
use tokio::net::TcpStream;
use crate::net::{crypto::SessionCrypto, framing, payloads::*, types::NetCommand};
pub async fn handle_cmd(
cmd: NetCommand,
stream: &mut TcpStream,
stream: &mut (impl tokio::io::AsyncWrite + Unpin),
seq: &mut u32,
crypto: &SessionCrypto,
) -> Result<()> {
match cmd {
NetCommand::GuildCreate { name } => {
let payload = serde_json::to_vec(&GuildCreatePayload {
name,
icon_url: None,
})?;
let payload = wire::encode(&GuildCreatePayload { name })?;
framing::io::write_encrypted(stream, PID_GUILD_CREATE, seq, &payload, crypto).await?;
}
NetCommand::GuildDelete { guild_id } => {
let payload = serde_json::to_vec(&GuildDeletePayload { guild_id })?;
let payload = wire::encode(&GuildDeletePayload { guild_id })?;
framing::io::write_encrypted(stream, PID_GUILD_DELETE, seq, &payload, crypto).await?;
}
NetCommand::GuildList => {
framing::io::write_encrypted(stream, PID_GUILD_LIST, seq, b"{}", crypto).await?;
framing::io::write_encrypted(stream, PID_GUILD_LIST, seq, b"", crypto).await?;
}
NetCommand::GuildJoin {
guild_id,
invite_code,
} => {
let payload = serde_json::to_vec(&GuildJoinPayload {
guild_id,
invite_code,
})?;
framing::io::write_encrypted(stream, PID_GUILD_MEMBER_JOIN, seq, &payload, crypto)
.await?;
if let Some(code) = invite_code {
let payload = wire::encode(&InviteAcceptPayload {
code,
..Default::default()
})?;
framing::io::write_encrypted(stream, PID_INVITE_ACCEPT, seq, &payload, crypto)
.await?;
} else {
let payload = wire::encode(&GuildJoinPayload { guild_id })?;
framing::io::write_encrypted(stream, PID_GUILD_MEMBER_JOIN, seq, &payload, crypto)
.await?;
}
}
NetCommand::GuildLeave { guild_id } => {
let payload = serde_json::to_vec(&GuildLeavePayload { guild_id })?;
let payload = wire::encode(&GuildLeavePayload {
guild_id,
user_id: String::new(),
})?;
framing::io::write_encrypted(stream, PID_GUILD_MEMBER_LEAVE, seq, &payload, crypto)
.await?;
}
@ -46,7 +51,7 @@ pub async fn handle_cmd(
max_uses,
expires_in_seconds,
} => {
let payload = serde_json::to_vec(&InviteCreatePayload {
let payload = wire::encode(&InviteCreatePayload {
guild_id,
max_uses,
expires_in_seconds,
@ -54,14 +59,17 @@ pub async fn handle_cmd(
framing::io::write_encrypted(stream, PID_INVITE_CREATE, seq, &payload, crypto).await?;
}
NetCommand::InviteAccept { code } => {
let payload = serde_json::to_vec(&InviteAcceptPayload { code })?;
let payload = wire::encode(&InviteAcceptPayload {
code,
..Default::default()
})?;
framing::io::write_encrypted(stream, PID_INVITE_ACCEPT, seq, &payload, crypto).await?;
}
NetCommand::InviteDelete {
guild_id,
invite_id,
} => {
let payload = serde_json::to_vec(&InviteDeletePayload {
let payload = wire::encode(&InviteDeletePayload {
guild_id,
invite_id,
})?;
@ -73,30 +81,31 @@ pub async fn handle_cmd(
color,
permissions,
} => {
let payload = serde_json::to_vec(&RoleCreatePayload {
let payload = wire::encode(&RoleCreatePayload {
guild_id,
name,
color,
permissions,
id: String::new(),
})?;
framing::io::write_encrypted(stream, PID_ROLE_CREATE, seq, &payload, crypto).await?;
}
NetCommand::RoleDelete { guild_id, role_id } => {
let payload = serde_json::to_vec(&RoleDeletePayload { guild_id, role_id })?;
let payload = wire::encode(&RoleDeletePayload { guild_id, role_id })?;
framing::io::write_encrypted(stream, PID_ROLE_DELETE, seq, &payload, crypto).await?;
}
NetCommand::GuildMemberKick { guild_id, user_id } => {
let payload = serde_json::to_vec(&GuildMemberKickPayload { guild_id, user_id })?;
let payload = wire::encode(&GuildMemberKickPayload { guild_id, user_id })?;
framing::io::write_encrypted(stream, PID_GUILD_MEMBER_KICK, seq, &payload, crypto)
.await?;
}
NetCommand::GuildAuditLogFetch { guild_id, limit } => {
let payload = serde_json::to_vec(&GuildAuditLogFetchPayload { guild_id, limit })?;
let payload = wire::encode(&GuildAuditLogFetchPayload { guild_id, limit })?;
framing::io::write_encrypted(stream, PID_GUILD_AUDIT_LOG_FETCH, seq, &payload, crypto)
.await?;
}
NetCommand::GuildMemberListFetch { guild_id } => {
let payload = serde_json::to_vec(&GuildMemberListFetchPayload { guild_id })?;
let payload = wire::encode(&GuildMemberListFetchPayload { guild_id })?;
framing::io::write_encrypted(
stream,
PID_GUILD_MEMBER_LIST_FETCH,
@ -111,7 +120,7 @@ pub async fn handle_cmd(
user_id,
role_id,
} => {
let payload = serde_json::to_vec(&RoleAssignPayload {
let payload = wire::encode(&RoleAssignPayload {
guild_id,
user_id,
role_id,
@ -124,7 +133,7 @@ pub async fn handle_cmd(
user_id,
role_id,
} => {
let payload = serde_json::to_vec(&RoleAssignPayload {
let payload = wire::encode(&RoleAssignPayload {
guild_id,
user_id,
role_id,
@ -133,7 +142,7 @@ pub async fn handle_cmd(
.await?;
}
NetCommand::GuildRoleListFetch { guild_id } => {
let payload = serde_json::to_vec(&GuildRoleListFetchPayload { guild_id })?;
let payload = wire::encode(&GuildRoleListFetchPayload { guild_id })?;
framing::io::write_encrypted(stream, PID_GUILD_ROLE_LIST_FETCH, seq, &payload, crypto)
.await?;
}

View file

@ -1,9 +1,8 @@
mod friends;
mod guild;
use crate::net::wire;
use anyhow::Result;
use serde_json;
use tokio::net::TcpStream;
use crate::identity::Identity;
use crate::net::{crypto::SessionCrypto, framing, payloads::*, types::NetCommand};
@ -12,12 +11,32 @@ use super::core::now_ms;
pub async fn handle_cmd(
cmd: NetCommand,
stream: &mut TcpStream,
stream: &mut (impl tokio::io::AsyncWrite + Unpin),
seq: &mut u32,
crypto: &SessionCrypto,
identity: &Identity,
) -> Result<()> {
match cmd {
NetCommand::MediaControl(message) => {
framing::io::write_encrypted(
stream,
PID_MEDIA_CONTROL,
seq,
&wire::encode(&message)?,
crypto,
)
.await?;
}
NetCommand::Webhook { operation, request } => {
framing::io::write_encrypted(
stream,
operation.packet_id(),
seq,
&wire::encode(&request)?,
crypto,
)
.await?;
}
cmd @ (NetCommand::GuildCreate { .. }
| NetCommand::GuildDelete { .. }
| NetCommand::GuildList
@ -52,7 +71,7 @@ pub async fn handle_cmd(
message_id,
emoji,
} => {
let payload = serde_json::to_vec(&ReactionPayload {
let payload = wire::encode(&ReactionPayload {
message_id,
channel_id,
emoji,
@ -66,7 +85,7 @@ pub async fn handle_cmd(
message_id,
emoji,
} => {
let payload = serde_json::to_vec(&ReactionPayload {
let payload = wire::encode(&ReactionPayload {
message_id,
channel_id,
emoji,
@ -86,7 +105,7 @@ pub async fn handle_cmd(
message_id,
content,
} => {
let payload = serde_json::to_vec(&MessageEditPayload {
let payload = wire::encode(&MessageEditPayload {
message_id,
channel_id,
content,
@ -97,14 +116,14 @@ pub async fn handle_cmd(
channel_id,
message_id,
} => {
let payload = serde_json::to_vec(&MessageDeletePayload {
let payload = wire::encode(&MessageDeletePayload {
message_id,
channel_id,
})?;
framing::io::write_encrypted(stream, PID_MESSAGE_DELETE, seq, &payload, crypto).await?;
}
NetCommand::DmStart { target_user_id } => {
let payload = serde_json::to_vec(&DmStartPayload { target_user_id })?;
let payload = wire::encode(&DmStartPayload { target_user_id })?;
framing::io::write_encrypted(stream, PID_DM_START, seq, &payload, crypto).await?;
}
NetCommand::DmSend { dm_id, content } => {
@ -114,25 +133,19 @@ pub async fn handle_cmd(
content,
timestamp: now_ms(),
};
framing::io::write_encrypted(
stream,
PID_DM_MESSAGE,
seq,
&serde_json::to_vec(&msg)?,
crypto,
)
.await?;
framing::io::write_encrypted(stream, PID_DM_MESSAGE, seq, &wire::encode(&msg)?, crypto)
.await?;
}
NetCommand::TypingStart { channel_id } => {
let payload = serde_json::to_vec(&serde_json::json!({"channel_id": channel_id}))?;
let payload = wire::encode(&TypingStart { channel_id })?;
framing::io::write_encrypted(stream, PID_TYPING_START, seq, &payload, crypto).await?;
}
NetCommand::DmReadAck { dm_id } => {
let payload = serde_json::to_vec(&serde_json::json!({"dm_id": dm_id}))?;
let payload = wire::encode(&crate::net::wire::DmReadAck { dm_id })?;
framing::io::write_encrypted(stream, PID_DM_READ_ACK, seq, &payload, crypto).await?;
}
NetCommand::DmSearch { dm_id, query } => {
let payload = serde_json::to_vec(&DmHistoryPayload {
let payload = wire::encode(&DmHistoryPayload {
dm_id,
messages: vec![],
search_query: if query.is_empty() { None } else { Some(query) },
@ -144,7 +157,7 @@ pub async fn handle_cmd(
dm_id,
e2ee_public_key,
} => {
let payload = serde_json::to_vec(&E2eeDmKeyExchangePayload {
let payload = wire::encode(&E2eeDmKeyExchangePayload {
dm_id,
e2ee_public_key,
})?;
@ -152,7 +165,7 @@ pub async fn handle_cmd(
.await?;
}
NetCommand::E2eeDmKeyExchangeAck { dm_id } => {
let payload = serde_json::to_vec(&E2eeDmKeyExchangeAckPayload { dm_id })?;
let payload = wire::encode(&E2eeDmKeyExchangeAckPayload { dm_id })?;
framing::io::write_encrypted(
stream,
PID_E2EE_DM_KEY_EXCHANGE_ACK,
@ -173,13 +186,13 @@ pub async fn handle_cmd(
stream,
PID_E2EE_DM_MESSAGE,
seq,
&serde_json::to_vec(&msg)?,
&wire::encode(&msg)?,
crypto,
)
.await?;
}
NetCommand::E2eeDmHistory { dm_id, limit } => {
let payload = serde_json::to_vec(&E2eeDmHistoryPayload {
let payload = wire::encode(&E2eeDmHistoryPayload {
dm_id,
messages: vec![],
limit,

View file

@ -1,47 +1,151 @@
use std::sync::Arc;
use crate::net::{
types::NetEvent,
voice::{self, Credentials, ReplayWindow},
};
use anyhow::Result;
use tokio::net::UdpSocket;
use tokio::sync::mpsc;
use std::{
net::SocketAddr,
sync::{Arc, Mutex},
};
use tokio::{net::UdpSocket, sync::mpsc};
use crate::net::{crypto::SessionCrypto, types::NetEvent};
pub struct State {
pub udp: Arc<UdpSocket>,
pub seq: u64,
struct ReceiveState {
credentials: Credentials,
endpoint: SocketAddr,
replay: ReplayWindow,
}
pub struct State {
udp: Arc<UdpSocket>,
credentials: Option<Credentials>,
endpoint: Option<SocketAddr>,
receive: Arc<Mutex<Option<ReceiveState>>>,
receiver: tokio::task::JoinHandle<()>,
sequence: u64,
}
impl State {
pub async fn new(crypto: &SessionCrypto, event_tx: &mpsc::Sender<NetEvent>) -> Result<Self> {
let udp = Arc::new(UdpSocket::bind("0.0.0.0:0").await?);
crate::net::voice::spawn_recv(udp.clone(), (*crypto).clone(), event_tx.clone());
Ok(Self { udp, seq: 0 })
pub async fn new(event_tx: &mpsc::Sender<NetEvent>, ipv6: bool) -> Result<Self> {
let udp = Arc::new(UdpSocket::bind(if ipv6 { "[::]:0" } else { "0.0.0.0:0" }).await?);
let receive = Arc::new(Mutex::new(None::<ReceiveState>));
let worker_udp = udp.clone();
let worker_state = receive.clone();
let events = event_tx.clone();
let receiver = tokio::spawn(async move {
let mut bytes = vec![0u8; voice::MAX_DATAGRAM + 1];
while let Ok((length, source)) = worker_udp.recv_from(&mut bytes).await {
let event = {
let Ok(mut state) = worker_state.lock() else {
break;
};
let Some(state) = state.as_mut() else {
continue;
};
if source != state.endpoint {
continue;
}
let Ok((sequence, frame)) = voice::decode(&state.credentials, &bytes[..length])
else {
continue;
};
if !state.replay.accept(sequence) || frame.opus.is_empty() {
continue;
}
NetEvent::VoicePacket {
channel_id: voice::channel_key(&frame.channel_id),
voice_seq: frame.voice_seq,
timestamp: frame.timestamp,
sender: source,
sender_id: frame.sender_user_id,
opus_data: frame.opus,
}
};
if events.send(event).await.is_err() {
break;
}
}
});
Ok(Self {
udp,
credentials: None,
endpoint: None,
receive,
receiver,
sequence: 0,
})
}
#[allow(clippy::too_many_arguments)]
pub async fn send_voice(
&mut self,
channel_id: u64,
voice_pkt_seq: u32,
timestamp: u32,
opus_data: &[u8],
crypto: &SessionCrypto,
endpoint: Option<std::net::SocketAddr>,
sender_pubkey: &[u8; 32],
) -> Result<()> {
if let Some(ep) = endpoint {
let pkt = crate::net::voice::build_packet(
channel_id,
voice_pkt_seq,
timestamp,
opus_data,
crypto,
self.seq,
sender_pubkey,
);
let _ = self.udp.send_to(&pkt, ep).await;
self.seq += 1;
pub async fn configure(&mut self, session: crate::net::wire::VoiceSession) -> Result<()> {
let credentials = Credentials::try_from(session)?;
if self
.credentials
.as_ref()
.is_some_and(|old| old.route_id == credentials.route_id)
{
anyhow::bail!("voice credentials must be fresh on each join");
}
self.credentials = Some(credentials);
self.sequence = 0;
self.sync_receive();
self.keep_alive().await
}
pub async fn set_endpoint(&mut self, endpoint: SocketAddr) -> Result<()> {
if self.endpoint == Some(endpoint) {
return Ok(());
}
self.endpoint = Some(endpoint);
self.sync_receive();
self.keep_alive().await
}
fn sync_receive(&self) {
if let Ok(mut state) = self.receive.lock() {
if let Some((credentials, endpoint)) = self.credentials.as_ref().zip(self.endpoint) {
if let Some(existing) = state
.as_mut()
.filter(|existing| existing.credentials.route_id == credentials.route_id)
{
existing.endpoint = endpoint;
} else {
*state = Some(ReceiveState {
credentials: credentials.clone(),
endpoint,
replay: ReplayWindow::default(),
});
}
} else {
*state = None;
}
}
}
pub fn channel_id(&self) -> Option<&str> {
self.credentials
.as_ref()
.map(|value| value.channel_id.as_str())
}
pub async fn keep_alive(&mut self) -> Result<()> {
self.send(None, 0, 0, b"").await
}
pub async fn send(
&mut self,
channel: Option<u64>,
voice_seq: u32,
timestamp: u32,
opus: &[u8],
) -> Result<()> {
let Some((credentials, endpoint)) = self.credentials.as_ref().zip(self.endpoint) else {
return Ok(());
};
if channel.is_some_and(|key| key != voice::channel_key(&credentials.channel_id)) {
return Ok(());
}
let packet = voice::encode(credentials, self.sequence, voice_seq, timestamp, opus)?;
self.sequence = self
.sequence
.checked_add(1)
.ok_or_else(|| anyhow::anyhow!("voice sequence exhausted"))?;
self.udp.send_to(&packet, endpoint).await?;
Ok(())
}
}
impl Drop for State {
fn drop(&mut self) {
self.receiver.abort();
}
}