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:
parent
8460fb28fd
commit
3d7dd5413b
65 changed files with 6048 additions and 1156 deletions
|
|
@ -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?,
|
||||
|
|
|
|||
|
|
@ -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?;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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?;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue