added partial functionality for endpoints

src/main.rs

@@ -38,7 +38,7 @@ fn main() {
 
     dotenv::dotenv().ok();
 
-    info!("starting auth server");
+    info!("starting auth server on {}:{}", *OWN_IP, *AUTH_SERVER_PORT);
 
     let (auth_server, auth_server_join_handle) =
         NexServer::new(SocketAddrV4::new(*OWN_IP, *AUTH_SERVER_PORT))

src/prudp/endpoint.rs

@@ -1,3 +1,19 @@
-pub struct Endpoint{
+use std::net::UdpSocket;
+use std::sync::Arc;
+use crate::prudp::packet::VirtualPort;
+use crate::prudp::server::Connection;
 
+pub struct Endpoint{
+    socket: Arc<UdpSocket>,
+    virtual_port: VirtualPort,
+}
+
+impl Endpoint{
+    pub fn get_virual_port(&self) -> VirtualPort{
+        self.virtual_port
+    }
+
+    fn process_packet(connection: &Connection){
+        
+    }
 }

src/prudp/mod.rs

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

src/prudp/packet.rs

@@ -2,10 +2,12 @@ use std::fmt::{Debug, Formatter};
 use std::hint::unreachable_unchecked;
 use std::io;
 use std::io::{Cursor, ErrorKind, Read, Seek};
+use std::net::SocketAddrV4;
 use bytemuck::{Pod, Zeroable};
 use thiserror::Error;
 use v_byte_macros::{EnumTryInto, SwapEndian};
 use crate::endianness::{IS_BIG_ENDIAN, IS_LITTLE_ENDIAN, ReadExtensions};
+use crate::prudp::sockaddr::PRUDPSockAddr;
 
 #[derive(Error, Debug)]
 pub enum Error{
@@ -62,11 +64,11 @@ pub struct VirtualPort(u8);
 
 impl VirtualPort{
     pub fn get_stream_type(self) -> u8 {
-        (self.0 & 0x0F) as u8
+        (self.0 & 0xF0) >> 4
     }
 
     pub fn get_port_number(self) -> u8 {
-        (self.0 & 0xF0) >> 4
+        (self.0 & 0x0F)
     }
 
     pub fn stream_type(self, val: u8) -> Self {
@@ -114,7 +116,8 @@ enum PacketSpecificData{
 
 #[derive(Debug)]
 pub struct PRUDPPacket{
-    pub header: PRUDPHeader
+    pub header: PRUDPHeader,
+    pub payload: Vec<u8>
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -208,14 +211,22 @@ impl PRUDPPacket{
         }*/
 
 
-        let mut packet_payload = vec![0u8; header.payload_size as usize];
+        let mut payload = vec![0u8; header.payload_size as usize];
 
-        reader.read_exact(&mut packet_payload)?;
+        reader.read_exact(&mut payload)?;
 
         Ok(Self{
-            header
+            header,
+            payload
         })
     }
+
+    pub fn source_sockaddr(&self,socket_addr_v4: SocketAddrV4) -> PRUDPSockAddr{
+        PRUDPSockAddr{
+            regular_socket_addr: socket_addr_v4,
+            virtual_port: self.header.source_port
+        }
+    }
 }
 
 #[cfg(test)]

src/prudp/server.rs

@@ -1,16 +1,18 @@
 use std::{env, io, thread};
 use std::io::Cursor;
 use std::marker::PhantomData;
-use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket};
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpStream, UdpSocket};
+use std::net::SocketAddr::V4;
 use std::ops::{Deref, DerefMut};
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, RwLock};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread::JoinHandle;
 use once_cell::sync::Lazy;
 use log::{error, info};
 use crate::prudp::auth_module::AuthModule;
 use crate::prudp::endpoint::Endpoint;
-use crate::prudp::packet::PRUDPPacket;
+use crate::prudp::packet::{PRUDPPacket, VirtualPort};
+use crate::prudp::sockaddr::PRUDPSockAddr;
 
 static SERVER_DATAGRAMS: Lazy<u8> = Lazy::new(||{
     env::var("SERVER_DATAGRAM_COUNT").ok()
@@ -19,30 +21,53 @@ static SERVER_DATAGRAMS: Lazy<u8> = Lazy::new(||{
 });
 
 pub struct NexServer{
-    pub endpoints: Mutex<Vec<Endpoint>>,
+    pub endpoints: RwLock<Vec<Endpoint>>,
     pub running: AtomicBool,
     //pub auth_module: Arc<dyn AuthModule>
     _no_outside_construction: PhantomData<()>
 }
 
+pub struct Connection<'a>{
+    socket: &'a UdpSocket,
+    prudp_addr: PRUDPSockAddr
+}
+
+
 impl NexServer{
     fn process_prudp_packet(&self, packet: &PRUDPPacket){
 
     }
-    fn process_prudp_packets(&self, addr: SocketAddr, udp_message: &[u8]){
+    fn process_prudp_packets<'a>(&self, socket: &'a UdpSocket, addr: SocketAddrV4, 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);
+                    error!("Somebody({}) is fucking with the servers or their connection is bad", addr);
                     break;
                 },
             };
 
             info!("got valid prudp packet from someone({}): \n{:?}", addr, packet);
 
+            let connection = Connection{
+                socket,
+                prudp_addr: packet.source_sockaddr(addr)
+            };
+
+            let endpoints = self.endpoints.read().expect("poison");
+
+            let Some(endpoint) = endpoints.iter().find(|e|{
+                e.get_virual_port().get_port_number() == connection.prudp_addr.virtual_port.get_port_number()
+            }) else {
+                error!("connection to invalid endpoint({}) attempted by {}", connection.prudp_addr.virtual_port.get_port_number(), connection.prudp_addr.regular_socket_addr);
+                continue;
+            };
+
+
+
+
 
         }
     }
@@ -57,9 +82,14 @@ impl NexServer{
             let (len, addr) = socket.recv_from(&mut msg_buffer)
                 .expect("Datagram thread crashed due to unexpected error from recv_from");
 
+            let V4(addr) = addr else {
+                error!("somehow got ipv6 packet...? ignoring");
+                continue;
+            };
+
             let current_msg = &msg_buffer[0..len];
             info!("attempting to process message");
-            self.process_prudp_packets(addr, current_msg);
+            self.process_prudp_packets(&socket, addr, current_msg);
         }
     }
     

src/prudp/sockaddr.rs

@@ -0,0 +1,7 @@
+use std::net::SocketAddrV4;
+use crate::prudp::packet::VirtualPort;
+
+pub struct PRUDPSockAddr{
+    pub regular_socket_addr: SocketAddrV4,
+    pub virtual_port: VirtualPort
+}