From 6177b564ee16d69047f1fab2329f53c161480a22 Mon Sep 17 00:00:00 2001 From: kozabrada123 <59031733+kozabrada123@users.noreply.github.com> Date: Wed, 27 Dec 2023 22:10:16 +0100 Subject: [PATCH] chore: yes clippy, you are special --- src/voice/crypto.rs | 2 +- src/voice/handler.rs | 43 ++++++++++++++++++++++++++++++------------- src/voice/mod.rs | 2 +- src/voice/udp.rs | 26 +++++++++++--------------- 4 files changed, 43 insertions(+), 30 deletions(-) diff --git a/src/voice/crypto.rs b/src/voice/crypto.rs index ccf39b6..1365ca7 100644 --- a/src/voice/crypto.rs +++ b/src/voice/crypto.rs @@ -12,5 +12,5 @@ pub(crate) fn get_xsalsa20_poly1305_nonce(packet: &[u8]) -> Vec { rtp_header.push(0); } - return rtp_header; + rtp_header } diff --git a/src/voice/handler.rs b/src/voice/handler.rs index e757f9a..c8ddd8c 100644 --- a/src/voice/handler.rs +++ b/src/voice/handler.rs @@ -1,11 +1,22 @@ -use std::{sync::Arc, net::SocketAddrV4}; +use std::{net::SocketAddrV4, sync::Arc}; use async_trait::async_trait; use tokio::sync::{Mutex, RwLock}; -use crate::{gateway::Observer, types::{VoiceServerUpdate, VoiceIdentify, VoiceReady, SessionDescription, GatewayReady, Snowflake, SelectProtocol, VoiceProtocol, SelectProtocolData, VoiceEncryptionMode}}; +use crate::{ + gateway::Observer, + types::{ + GatewayReady, SelectProtocol, SelectProtocolData, SessionDescription, Snowflake, + VoiceEncryptionMode, VoiceIdentify, VoiceProtocol, VoiceReady, VoiceServerUpdate, + }, +}; -use super::{gateway::{VoiceGatewayHandle, VoiceGateway}, udp::UdpHandle, udp::UdpHandler, voice_data::VoiceData}; +use super::{ + gateway::{VoiceGateway, VoiceGatewayHandle}, + udp::UdpHandle, + udp::UdpHandler, + voice_data::VoiceData, +}; /// Handles inbetween connections between the gateway and udp modules #[derive(Debug, Clone)] @@ -26,13 +37,19 @@ impl VoiceHandler { } } +impl Default for VoiceHandler { + fn default() -> Self { + Self::new() + } +} + #[async_trait] // On [VoiceServerUpdate] we get our starting data and url for the voice gateway server. impl Observer for VoiceHandler { async fn update(&self, data: &VoiceServerUpdate) { let mut data_lock = self.data.write().await; data_lock.server_data = Some(data.clone()); - let user_id = data_lock.user_id.clone(); + let user_id = data_lock.user_id; let session_id = data_lock.session_id.clone(); drop(data_lock); @@ -43,9 +60,9 @@ impl Observer for VoiceHandler { let server_id: Snowflake; if data.guild_id.is_some() { - server_id = data.guild_id.clone().unwrap(); + server_id = data.guild_id.unwrap(); } else { - server_id = data.channel_id.clone().unwrap(); + server_id = data.channel_id.unwrap(); } let voice_identify = VoiceIdentify { @@ -65,7 +82,9 @@ impl Observer for VoiceHandler { let self_reference = Arc::new(self.clone()); voice_events.voice_ready.subscribe(self_reference.clone()); - voice_events.session_description.subscribe(self_reference.clone()); + voice_events + .session_description + .subscribe(self_reference.clone()); *self.voice_gateway_connection.lock().await = Some(voice_gateway_handle); } @@ -76,14 +95,13 @@ impl Observer for VoiceHandler { // connection for ip discovery. impl Observer for VoiceHandler { async fn update(&self, data: &VoiceReady) { - let mut data_lock = self.data.write().await; data_lock.ready_data = Some(data.clone()); - drop(data_lock); + drop(data_lock); let udp_handle = UdpHandler::spawn( self.data.clone(), - std::net::SocketAddr::V4(SocketAddrV4::new(data.ip.clone(), data.port)), + std::net::SocketAddr::V4(SocketAddrV4::new(data.ip, data.port)), data.ssrc, ) .await; @@ -114,7 +132,6 @@ impl Observer for VoiceHandler { // Session descryption gives us final info regarding codecs and our encryption key impl Observer for VoiceHandler { async fn update(&self, data: &SessionDescription) { - let mut data_write = self.data.write().await; data_write.session_description = Some(data.clone()); @@ -127,8 +144,8 @@ impl Observer for VoiceHandler { impl Observer for VoiceHandler { async fn update(&self, data: &GatewayReady) { let mut lock = self.data.write().await; - lock.user_id = data.user.id.clone(); + lock.user_id = data.user.id; lock.session_id = data.session_id.clone(); drop(lock); } -} +} diff --git a/src/voice/mod.rs b/src/voice/mod.rs index e672ea8..621d3c0 100644 --- a/src/voice/mod.rs +++ b/src/voice/mod.rs @@ -2,9 +2,9 @@ mod crypto; pub mod gateway; +pub mod handler; pub mod udp; pub mod voice_data; -pub mod handler; // Pub use this so users can interact with packet types if they want pub use discortp; diff --git a/src/voice/udp.rs b/src/voice/udp.rs index 38d71c2..9b6f9cf 100644 --- a/src/voice/udp.rs +++ b/src/voice/udp.rs @@ -292,16 +292,14 @@ impl UdpHandler { let session_description = session_description_result.unwrap(); - let nonce_bytes; - - match session_description.encryption_mode { + let nonce_bytes = match session_description.encryption_mode { crate::types::VoiceEncryptionMode::Xsalsa20Poly1305 => { - nonce_bytes = crypto::get_xsalsa20_poly1305_nonce(rtp.packet()); + crypto::get_xsalsa20_poly1305_nonce(rtp.packet()) } _ => { unimplemented!(); } - } + }; let nonce = GenericArray::from_slice(&nonce_bytes); @@ -346,15 +344,13 @@ impl UdpHandler { } Demuxed::Rtcp(rtcp) => { trace!("VUDP: Parsed packet as rtcp!"); - - let rtcp_data; - - match rtcp { + + let rtcp_data = match rtcp { discortp::rtcp::RtcpPacket::KnownType(knowntype) => { - rtcp_data = discortp::rtcp::Rtcp::KnownType(knowntype); + discortp::rtcp::Rtcp::KnownType(knowntype) } discortp::rtcp::RtcpPacket::SenderReport(senderreport) => { - rtcp_data = discortp::rtcp::Rtcp::SenderReport(SenderReport { + discortp::rtcp::Rtcp::SenderReport(SenderReport { payload: senderreport.payload().to_vec(), padding: senderreport.get_padding(), version: senderreport.get_version(), @@ -362,10 +358,10 @@ impl UdpHandler { pkt_length: senderreport.get_pkt_length(), packet_type: senderreport.get_packet_type(), rx_report_count: senderreport.get_rx_report_count(), - }); + }) } discortp::rtcp::RtcpPacket::ReceiverReport(receiverreport) => { - rtcp_data = discortp::rtcp::Rtcp::ReceiverReport(ReceiverReport { + discortp::rtcp::Rtcp::ReceiverReport(ReceiverReport { payload: receiverreport.payload().to_vec(), padding: receiverreport.get_padding(), version: receiverreport.get_version(), @@ -373,12 +369,12 @@ impl UdpHandler { pkt_length: receiverreport.get_pkt_length(), packet_type: receiverreport.get_packet_type(), rx_report_count: receiverreport.get_rx_report_count(), - }); + }) } _ => { unreachable!(); } - } + }; self.events.lock().await.rtcp.notify(rtcp_data).await; }