added framework for auth server

src/main.rs

@@ -1,6 +1,44 @@
+use std::env::current_dir;
+use std::{env, fs};
+use std::fs::File;
+use std::net::{Ipv4Addr, SocketAddrV4};
+use chrono::Local;
+use log::info;
+use once_cell::sync::Lazy;
+use simplelog::{ColorChoice, CombinedLogger, Config, LevelFilter, TerminalMode, TermLogger, WriteLogger};
+use crate::prudp::server::NexServer;
+
 mod endianness;
 mod prudp;
 
+static AUTH_SERVER_PORT: Lazy<u16> = Lazy::new(||{
+    env::var("AUTH_SERVER_PORT")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(10000)
+});
+
+
 fn main() {
-    println!("Hello, world!");
+    CombinedLogger::init(
+        vec![
+            TermLogger::new(LevelFilter::Info, Config::default(), TerminalMode::Mixed, ColorChoice::Auto),
+            WriteLogger::new(LevelFilter::Info, Config::default(), {
+                fs::create_dir_all("log").unwrap();
+                File::create(format!("log/{}.log", Local::now().to_rfc2822())).unwrap()
+            })
+        ]
+    ).unwrap();
+
+    dotenv::dotenv().ok();
+
+    info!("starting auth server");
+
+    let (auth_server, auth_server_join_handle) =
+        NexServer::new(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, *AUTH_SERVER_PORT))
+        .expect("unable to startauth server");
+
+    info!("joining auth server");
+
+    auth_server_join_handle.join().unwrap();
 }

src/prudp/auth_module.rs

@@ -0,0 +1,14 @@
+use std::net::Ipv4Addr;
+use rc4::Rc4;
+
+pub trait AuthModule{
+    fn get_auth_key(addr: Ipv4Addr) -> [u8; 32];
+}
+/*
+struct AuthServerAuthModule;
+
+impl AuthModule for AuthServerAuthModule{
+    fn get_auth_key(addr: Ipv4Addr) -> rc4 {
+
+    }
+}*/

src/prudp/mod.rs

@@ -1,4 +1,4 @@
 pub mod packet;
-mod server;
+pub mod server;
 mod endpoint;
 mod auth_module;

src/prudp/server.rs

@@ -1,42 +1,89 @@
+use std::{env, io, thread};
+use std::io::Cursor;
 use std::marker::PhantomData;
+use std::net::{Ipv4Addr, SocketAddrV4, UdpSocket};
 use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, Mutex};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread::JoinHandle;
+use once_cell::sync::Lazy;
+use log::error;
+use crate::prudp::auth_module::AuthModule;
 use crate::prudp::endpoint::Endpoint;
+use crate::prudp::packet::PRUDPPacket;
+
+static SERVER_DATAGRAMS: Lazy<u8> = Lazy::new(||{
+    env::var("SERVER_DATAGRAM_COUNT").ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(1)
+});
 
 pub struct NexServer{
     pub endpoints: Mutex<Vec<Endpoint>>,
+    pub running: AtomicBool,
+    //pub auth_module: Arc<dyn AuthModule>
     _no_outside_construction: PhantomData<()>
 }
 
 impl NexServer{
-    fn server_thread_entry(){
-            
+    fn process_prudp_packet(&self, packet: &PRUDPPacket){
+
+    }
+    fn process_prudp_packets(&self, addr: Ipv4Addr, udp_message: &[u8]){
+        let mut stream = Cursor::new(udp_message);
+
+        while stream.position() as usize != udp_message.len() {
+            let packet = match PRUDPPacket::new(&mut stream){
+                Ok(p) => p,
+                Err(e) => {
+                    error!("Somebody is fucking with the servers or their connection is bad(from {})", addr);
+                    break;
+                },
+            };
+
+
+        }
+    }
+
+    fn server_thread_entry(self: Arc<Self>, socket: Arc<UdpSocket>){
+        while self.running.load(Ordering::Relaxed) {
+            // yes we actually allow the max udp to be read lol
+            let mut msg_buffer = vec![0u8; 65507];
+
+            let (len, addr) = socket.recv_from(&mut msg_buffer)
+                .expect("Datagram thread crashed due to unexpected error from recv_from");
+
+            let current_msg = &msg_buffer[0..len];
+
+
+        }
     }
     
-    pub fn new() -> Arc<Self>{
+    pub fn new(addr: SocketAddrV4) -> io::Result<(Arc<Self>, JoinHandle<()>)>{
         let own_impl = NexServer{
             endpoints: Default::default(),
+            running: AtomicBool::new(true),
             _no_outside_construction: Default::default()
         };
 
         let arc = Arc::new(own_impl);
+
+        let socket = Arc::new(UdpSocket::bind(addr)?);
+
+        let mut thread = None;
+
+        for _ in 0..*SERVER_DATAGRAMS {
+            let socket = socket.clone();
+            let server= arc.clone();
+            thread = Some(thread::spawn(move || {
+                server.server_thread_entry(socket);
+            }));
+        }
+
+        let thread = thread.expect("cannot have less than 1 thread for a server");
+
+
+        Ok((arc, thread))
     }
 }
 
-#[cfg(test)]
-mod test{
-    use std::ops::Deref;
-    use std::sync::Arc;
-    use crate::prudp::server::{NexServer};
-
-    #[test]
-    fn test(){
-        let server = NexServer::new();
-
-        let a = (server.deref()).clone();
-
-    }
-}
-
-
-