use std::time::Duration; 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 super::super::switch::ReconnectRequested; use super::{VoiceState, handle_cmd}; pub async fn session_loop( identity: &Identity, address: &str, channels: &mut Vec, restored: bool, cmd_rx: &mut mpsc::Receiver, event_tx: &mpsc::Sender, ) -> Result<()> { 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) = 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(), node_name, restored, private_mode, }) .await; for channel_id in channels.clone() { framing::io::write_encrypted( &mut stream, PID_JOIN_CHANNEL, &mut seq, &wire::encode(&JoinChannelPayload { channel_id })?, &crypto, ) .await?; } let (reader, mut stream) = tokio::io::split(stream); let mut incoming = framing::io::Reader::new(reader, crypto.clone()); let mut voice_state: Option = None; let mut used_voice_routes = std::collections::HashSet::new(); let mut voice_endpoint: Option = 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 = wire::encode(&PingPayload { timestamp: ts })?; framing::io::write_encrypted(&mut stream, PID_PING, &mut seq, &payload, &crypto).await?; } 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) = wire::decode::(&pkt.payload) && p.kind == "voice" && !p.voice_endpoint.is_empty() { 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?; } cmd = cmd_rx.recv() => { match cmd { None | Some(NetCommand::Disconnect) => { let _ = framing::io::write_encrypted(&mut stream, PID_DISCONNECT, &mut seq, &wire::encode(&Disconnect {reason: "bye".into()})?, &crypto).await; return Ok(()); } Some(NetCommand::Connect { address, auto_reconnect }) => { warn!("connect while connected to {address}, reconnecting"); if channels.is_empty() { *channels = vec!["general".into()]; } return Err(anyhow::Error::new(ReconnectRequested { address, auto_reconnect, })); } Some(NetCommand::JoinChannel { channel_id }) => { track_channel(channels, &channel_id); framing::io::write_encrypted(&mut stream, PID_JOIN_CHANNEL, &mut seq, &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, &wire::encode(&LeaveChannelPayload { channel_id })?, &crypto).await?; } Some(NetCommand::ChannelCreate { channel_id, channel_name, kind, guild_id }) => { let payload = wire::encode(&ChannelCreatePayload { channel_id, channel_name, kind, guild_id, })?; framing::io::write_encrypted(&mut stream, PID_CHANNEL_CREATE, &mut seq, &payload, &crypto).await?; } Some(NetCommand::ChannelDelete { 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?; } Some(NetCommand::SendChat { channel_id, content, reply_to }) => { let msg = ChatMessagePayload { message_id: uuid_v4(), channel_id, sender_id: identity.pubkey_hex.clone(), content, timestamp: now_ms(), edited: false, reply_to, }; 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 }) => { 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 = 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?, } } } } } pub(super) fn now_ms() -> i64 { std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap_or_default() .as_millis() as i64 } pub(super) fn uuid_v4() -> String { uuid::Uuid::new_v4().to_string() } fn track_channel(channels: &mut Vec, channel_id: &str) { if !channels.iter().any(|c| c == channel_id) { channels.push(channel_id.to_string()); } }