Merge pull request #3 from Perditum/fix/warnings

src/kerberos/mod.rs

@@ -71,7 +71,7 @@ impl KerberosDateTime{
 
     #[inline]
     pub fn get_year(&self) -> u64{
-        ((self.0 >> 26) & 0xFFFFFFFF)
+        (self.0 >> 26) & 0xFFFFFFFF
     }
 
     pub fn to_regular_time(&self) -> chrono::DateTime<Utc>{

src/main.rs

@@ -7,12 +7,11 @@ use std::net::{Ipv4Addr, SocketAddrV4};
 use std::sync::Arc;
 use chrono::Local;
 use log::info;
-use macros::RmcSerialize;
 use once_cell::sync::Lazy;
 use rc4::{KeyInit, Rc4, StreamCipher};
 use rc4::consts::U5;
 use simplelog::{ColorChoice, CombinedLogger, Config, LevelFilter, TerminalMode, TermLogger, WriteLogger};
-use tokio::sync::{Mutex, RwLock};
+use tokio::sync::RwLock;
 use tokio::task::JoinHandle;
 use crate::nex::account::Account;
 use crate::protocols::{auth, block_if_maintenance};
@@ -20,12 +19,11 @@ use crate::protocols::auth::AuthProtocolConfig;
 use crate::protocols::matchmake_common::MatchmakeData;
 use crate::protocols::server::RMCProtocolServer;
 use crate::prudp::socket::{ActiveSecureConnectionData, EncryptionPair, Socket};
-use crate::prudp::packet::{PRUDPPacket, VirtualPort};
+use crate::prudp::packet::{VirtualPort};
 use crate::prudp::router::Router;
 use crate::prudp::secure::{generate_secure_encryption_pairs, read_secure_connection_data};
 use crate::rmc::message::RMCMessage;
 use crate::rmc::structures::RmcSerialize;
-use crate::rmc::structures::variant::Variant;
 
 mod endianness;
 mod prudp;
@@ -121,7 +119,7 @@ async fn start_auth_server() -> AuthServer{
         Box::new(auth::bound_protocol(auth_protocol_config))
     ]));
 
-    let mut socket =
+    let socket =
         Socket::new(
             router.clone(),
             VirtualPort::new(1,10),
@@ -131,7 +129,7 @@ async fn start_auth_server() -> AuthServer{
                     async move {
 
 
-                        let encryption_pairs = Vec::from_iter((0..=count).map(|v| {
+                        let encryption_pairs = Vec::from_iter((0..=count).map(|_v| {
                             let rc4: Rc4<U5> = Rc4::new_from_slice( "CD&ML".as_bytes()).unwrap();
                             let cypher = Box::new(rc4);
                             let server_cypher: Box<dyn StreamCipher + Send> = cypher;
@@ -191,7 +189,7 @@ async fn start_secure_server() -> SecureServer{
         Box::new(protocols::matchmake_extension::bound_protocol(matchmake_data))
     ]));
 
-    let mut socket =
+    let socket =
         Socket::new(
             router.clone(),
             VirtualPort::new(1,10),

src/protocols/auth/method_login.rs

@@ -2,7 +2,6 @@ use std::io::Cursor;
 use std::sync::Arc;
 use log::error;
 use tokio::sync::Mutex;
-use crate::nex::account::Account;
 use crate::protocols::auth::AuthProtocolConfig;
 use crate::prudp::socket::{ConnectionData, SocketData};
 use crate::rmc::message::RMCMessage;
@@ -15,7 +14,7 @@ pub async fn login(rmcmessage: &RMCMessage, _name: &str) -> RMCResponseResult{
     rmcmessage.error_result_with_code(ErrorCode::Core_NotImplemented)
 }
 
-pub async fn login_raw_params(rmcmessage: &RMCMessage, _: &Arc<SocketData>, _: &Arc<Mutex<ConnectionData>>, data: AuthProtocolConfig) -> RMCResponseResult{
+pub async fn login_raw_params(rmcmessage: &RMCMessage, _: &Arc<SocketData>, _: &Arc<Mutex<ConnectionData>>, _data: AuthProtocolConfig) -> RMCResponseResult{
     let mut reader = Cursor::new(&rmcmessage.rest_of_data);
 
     let Ok(str) = String::deserialize(&mut reader) else {

src/protocols/auth/method_login_ex.rs

@@ -1,12 +1,10 @@
 use std::io::{Cursor, Write};
 use std::sync::Arc;
 use bytemuck::bytes_of;
-use hex::encode;
 use log::{error};
 use tokio::sync::Mutex;
 use crate::grpc::account;
 use crate::kerberos::KerberosDateTime;
-use crate::nex::account::Account;
 use crate::protocols::auth::AuthProtocolConfig;
 use crate::protocols::auth::ticket_generation::generate_ticket;
 use crate::prudp::socket::{ConnectionData, SocketData};

src/protocols/auth/method_request_ticket.rs

@@ -1,17 +1,13 @@
 use std::io::Cursor;
 use std::sync::Arc;
-use log::error;
 use tokio::sync::Mutex;
 use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
-use crate::grpc::account;
 use crate::protocols::auth::{AuthProtocolConfig, get_login_data_by_pid};
-use crate::protocols::auth::method_login_ex::login_ex;
 use crate::protocols::auth::ticket_generation::generate_ticket;
 use crate::prudp::socket::{ConnectionData, SocketData};
 use crate::rmc::message::RMCMessage;
 use crate::rmc::response::{ErrorCode, RMCResponseResult};
 use crate::rmc::response::ErrorCode::Core_Unknown;
-use crate::rmc::structures::any::Any;
 use crate::rmc::structures::qresult::QResult;
 use crate::rmc::structures::RmcSerialize;
 

src/protocols/auth/mod.rs

@@ -3,16 +3,12 @@ mod method_login;
 mod ticket_generation;
 mod method_request_ticket;
 
-use std::sync::Arc;
-use log::{error};
 use crate::define_protocol;
 use crate::grpc::account;
 use crate::nex::account::Account;
 use crate::protocols::auth::method_login::login_raw_params;
 use crate::protocols::auth::method_login_ex::login_ex_raw_params;
 use crate::protocols::auth::method_request_ticket::request_ticket_raw_params;
-use crate::rmc::message::RMCMessage;
-use crate::rmc::response::{ErrorCode, RMCResponse};
 
 #[derive(Copy, Clone)]
 pub struct AuthProtocolConfig {

src/protocols/matchmake/method_unregister_gathering.rs

@@ -1,6 +1,5 @@
 use std::io::Cursor;
 use std::sync::Arc;
-use log::info;
 use tokio::sync::{Mutex, RwLock};
 use crate::protocols::matchmake_common::MatchmakeData;
 use crate::prudp::socket::{ConnectionData, SocketData};

src/protocols/matchmake_common/mod.rs

@@ -1,4 +1,4 @@
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap};
 use std::sync::Arc;
 use log::error;
 use tokio::sync::Mutex;

src/protocols/matchmake_extension/method_auto_matchmake_with_param_postpone.rs

@@ -6,7 +6,7 @@ use crate::protocols::matchmake_common::{ExtendedMatchmakeSession, MatchmakeData
 use crate::prudp::socket::{ConnectionData, SocketData};
 use crate::rmc::message::RMCMessage;
 use crate::rmc::response::{ErrorCode, RMCResponseResult};
-use crate::rmc::structures::matchmake::{AutoMatchmakeParam, MatchmakeSession};
+use crate::rmc::structures::matchmake::{AutoMatchmakeParam};
 use crate::rmc::structures::RmcSerialize;
 
 

src/protocols/matchmake_extension/method_get_playing_session.rs

@@ -10,7 +10,7 @@ use crate::rmc::structures::RmcSerialize;
 
 type PIDList = Vec<u32>;
 
-async fn get_playing_session(rmcmessage: &RMCMessage, data: Arc<RwLock<MatchmakeData>>) -> RMCResponseResult {
+async fn get_playing_session(rmcmessage: &RMCMessage, _data: Arc<RwLock<MatchmakeData>>) -> RMCResponseResult {
     //todo: propperly implement this
 
     let cheeseburger = PIDList::new();

src/protocols/matchmake_extension/mod.rs

@@ -2,7 +2,7 @@ mod method_get_playing_session;
 mod method_auto_matchmake_with_param_postpone;
 
 use std::sync::Arc;
-use tokio::sync::{Mutex, RwLock};
+use tokio::sync::{RwLock};
 use crate::define_protocol;
 use crate::protocols::matchmake_common::MatchmakeData;
 use method_get_playing_session::get_playing_session_raw_params;

src/protocols/mod.rs

@@ -35,7 +35,7 @@ static BYPASS_LEVEL: Lazy<i32> = Lazy::new(|| {
 
 pub fn block_if_maintenance<'a>(rmcmessage: &'a RMCMessage, _: &'a Arc<SocketData> , conn: &'a Arc<Mutex<ConnectionData>>) -> Pin<Box<(dyn Future<Output=Option<RMCResponse>> + Send + 'a)>> {
     Box::pin(async move {
-        let mut conn = conn.lock().await;
+        let conn = conn.lock().await;
 
         if let Some(active_conn) = conn.active_connection_data.as_ref() {
             if let Some(secure_conn) = active_conn.active_secure_connection_data.as_ref() {

src/protocols/secure/method_register.rs

@@ -1,22 +1,19 @@
 use std::io::{Cursor, Write};
 use std::sync::Arc;
 use bytemuck::bytes_of;
-use log::{error, warn};
 use tokio::sync::Mutex;
-use crate::protocols::auth::AuthProtocolConfig;
 use crate::prudp::socket::{ConnectionData, SocketData};
 use crate::prudp::station_url::{nat_types, StationUrl};
 use crate::prudp::station_url::Type::PRUDPS;
 use crate::prudp::station_url::UrlOptions::{Address, NatFiltering, NatMapping, NatType, Port, PrincipalID, RVConnectionID};
 use crate::rmc::message::RMCMessage;
 use crate::rmc::response::{ErrorCode, RMCResponseResult};
-use crate::rmc::structures::any::Any;
 use crate::rmc::structures::qresult::QResult;
 use crate::rmc::structures::RmcSerialize;
 
 type StringList = Vec<String>;
 
-pub async fn register(rmcmessage: &RMCMessage, station_urls: Vec<StationUrl>, conn_data: &Arc<Mutex<ConnectionData>>) -> RMCResponseResult{
+pub async fn register(rmcmessage: &RMCMessage, _station_urls: Vec<StationUrl>, conn_data: &Arc<Mutex<ConnectionData>>) -> RMCResponseResult{
     let locked = conn_data.lock().await;
     let Some(active_connection_data) = locked.active_connection_data.as_ref() else {
         return rmcmessage.error_result_with_code(ErrorCode::RendezVous_NotAuthenticated)

src/protocols/secure/method_send_report.rs

@@ -3,11 +3,9 @@ use std::sync::Arc;
 use log::error;
 use tokio::sync::Mutex;
 use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
-use crate::protocols::secure::method_register::register;
 use crate::prudp::socket::{ConnectionData, SocketData};
-use crate::prudp::station_url::StationUrl;
 use crate::rmc::message::RMCMessage;
-use crate::rmc::response::{ErrorCode, RMCResponseResult};
+use crate::rmc::response::{RMCResponseResult};
 use crate::rmc::response::ErrorCode::Core_InvalidArgument;
 use crate::rmc::structures::qbuffer;
 
@@ -22,7 +20,7 @@ pub async fn send_report(rmcmessage: &RMCMessage, report_id: u32, data: Vec<u8>)
     return rmcmessage.success_with_data(Vec::new());
 }
 
-pub async fn send_report_raw_params(rmcmessage: &RMCMessage, _: &Arc<SocketData>, conn_data: &Arc<Mutex<ConnectionData>>, _: ()) -> RMCResponseResult{
+pub async fn send_report_raw_params(rmcmessage: &RMCMessage, _: &Arc<SocketData>, _conn_data: &Arc<Mutex<ConnectionData>>, _: ()) -> RMCResponseResult{
     let mut reader = Cursor::new(&rmcmessage.rest_of_data);
 
     let Ok(error_id) = reader.read_struct(IS_BIG_ENDIAN) else {

src/prudp/secure.rs

@@ -7,7 +7,6 @@ use rc4::consts::U16;
 use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
 use crate::kerberos::{derive_key, TicketInternalData};
 use crate::nex::account::Account;
-use crate::prudp::packet::PRUDPHeader;
 use crate::prudp::socket::EncryptionPair;
 use crate::rmc::structures::RmcSerialize;
 

src/prudp/socket.rs

@@ -4,8 +4,8 @@ use std::ops::Deref;
 use std::pin::Pin;
 use tokio::net::UdpSocket;
 use std::sync::{Arc};
-use tokio::sync::{Mutex, MutexGuard, RwLock};
-use log::{error, info, trace, warn};
+use tokio::sync::{Mutex, RwLock};
+use log::{error, trace, warn};
 use rand::random;
 use rc4::StreamCipher;
 use crate::prudp::packet::{PacketOption, PRUDPPacket, VirtualPort};

src/rmc/response.rs

@@ -1,7 +1,6 @@
 use std::io;
 use std::io::{Write};
 use std::mem::transmute;
-use std::time::Duration;
 use bytemuck::bytes_of;
 use crate::prudp::packet::{PRUDPPacket};
 use crate::prudp::packet::flags::{NEED_ACK, RELIABLE};

src/rmc/structures/buffer.rs

@@ -1,5 +1,4 @@
 use std::io::{Read, Write};
-use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
 use crate::rmc::structures::RmcSerialize;
 
 impl<'a> RmcSerialize for &'a [u8]{
@@ -12,7 +11,7 @@ impl<'a> RmcSerialize for &'a [u8]{
     }
 
     /// DO NOT USE (also maybe split off the serialize and deserialize functions at some point)
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(_reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
         panic!("cannot deserialize to a u8 slice reference (use this ONLY for writing)")
     }
 }

src/rmc/structures/connection_data.rs

@@ -12,7 +12,7 @@ pub struct ConnectionData<'a>{
 
 impl<'a> RmcSerialize for ConnectionData<'a>{
     fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
-        rmc_struct::write_struct(writer, 1, |mut v|{
+        rmc_struct::write_struct(writer, 1, |v|{
             self.station_url.serialize(v).expect("unable to write station url");
             self.special_protocols.serialize(v).expect("unable to write special protocols");
             self.special_station_url.serialize(v).expect("unable to write special station url");
@@ -22,7 +22,7 @@ impl<'a> RmcSerialize for ConnectionData<'a>{
         })
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(_reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
         todo!()
     }
 }

src/rmc/structures/matchmake.rs

@@ -1,6 +1,5 @@
 use macros::RmcSerialize;
 use crate::kerberos::KerberosDateTime;
-use crate::rmc::structures::RmcSerialize;
 use crate::rmc::structures::variant::Variant;
 
 // rmc structure

src/rmc/structures/primitives.rs

@@ -72,7 +72,7 @@ impl RmcSerialize for bool{
         Ok(())
     }
 
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
         Ok(u8::deserialize(reader)? != 0)
     }
 }

src/rmc/structures/rmc_struct.rs

@@ -10,7 +10,7 @@ struct StructureHeader{
     length: u32
 }
 
-pub fn write_struct(mut writer: &mut dyn Write, version: u8, pred: impl FnOnce(&mut Vec<u8>) -> Result<()> ) -> Result<()> {
+pub fn write_struct(writer: &mut dyn Write, version: u8, pred: impl FnOnce(&mut Vec<u8>) -> Result<()> ) -> Result<()> {
     writer.write_all(&[version])?;
 
     let mut scratch_space: Vec<u8> = Vec::new();

src/rmc/structures/string.rs

@@ -23,7 +23,7 @@ impl RmcSerialize for String{
 }
 
 impl RmcSerialize for &str{
-    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+    fn deserialize(_reader: &mut dyn Read) -> Result<Self> {
         panic!("cannot serialize to &str")
     }
     fn serialize(&self, writer: &mut dyn Write) -> Result<()> {