Fix address parsing

app/Cargo.toml

@@ -9,3 +9,7 @@ workspace = true
 [dependencies]
 eframe = { version = "0.33.3", default-features = false, features = ["default_fonts", "glow"] }
 egui_extras = { version = "0.33.3" }
+bgtu-networks-2-network-abstract = { path = "../network/abstract" }
+
+[target.'cfg(windows)'.dependencies]
+bgtu-networks-2-network-windows = { path = "../network/windows" }

app/src/main.rs

@@ -1,3 +1,46 @@
-mod data;
+use bgtu_networks_2_network_abstract::{Address, NetworkContext, NetworkScope, ServersContext};
+use bgtu_networks_2_network_windows::winsocks_scope_2_2;
 
-fn main() {}
+// mod data;
+
+fn main() {
+    winsocks_scope_2_2(NetworkMain {});
+}
+
+struct NetworkMain {}
+
+impl NetworkScope for NetworkMain {
+    type R = ();
+
+    fn run<Ctx: NetworkContext>(self, network: &mut Ctx) -> Self::R {
+        let mut servers = Servers2NetworkCtxTestImpl {
+            loopback: Ctx::Address::parse("127.0.0.1").unwrap(),
+            ros_com_nadzor: Ctx::Address::parse("ya.ru").unwrap(),
+        };
+
+        Ctx::run_ping_eventloop(&mut servers)
+    }
+}
+
+struct Servers2NetworkCtxTestImpl<A: Address> {
+    loopback: A,
+    ros_com_nadzor: A,
+}
+
+impl<A: Address> ServersContext<A> for Servers2NetworkCtxTestImpl<A> {
+    fn start_measuring(&mut self) -> (u64, impl Iterator<Item = A>) {
+        return (
+            0,
+            [self.loopback.clone(), self.ros_com_nadzor.clone()].into_iter(),
+        );
+    }
+
+    fn report_ping(&mut self, addr: A, id: u64, ping_ms: u64) {
+        println!("{} {ping_ms}", addr.to_string())
+    }
+
+    fn report_error(&mut self, addr: A, id: u64) {
+        println!("{} err", addr.to_string())
+
+    }
+}

network/abstract/src/lib.rs

@@ -1,10 +1,10 @@
-pub trait Address: Sized {
+pub trait Address: Sized + Clone {
     fn parse(raw: &str) -> Result<Self, String>;
     fn to_string(self) -> String;
 }
 
 pub trait NetworkContext {
-    type Address: Address;
+    type Address: Address ;
 
     fn run_ping_eventloop(ctx: &mut impl ServersContext<Self::Address>);
 }
@@ -20,5 +20,5 @@ pub trait ServersContext<A: Address> {
 pub trait NetworkScope {
     type R;
 
-    fn run(self, network: &mut impl NetworkContext) -> Self::R;
+    fn run<Ctx: NetworkContext>(self, network: &mut Ctx) -> Self::R;
 }

network/windows/Cargo.toml

@@ -12,10 +12,4 @@ bgtu-networks-2-network-abstract = { path = "../abstract" }
 [dependencies.windows]
 version = ">=0.41.0, <=0.62.2"
 registry = "crates-io"
-features = [
-	"Win32_System_IO",
-	"Win32_Networking",
-	"Win32_Networking_WinSock",
-	"Win32_System_Diagnostics",
-	"Win32_System_Diagnostics_Debug"
-]
+features = ["Win32_System_IO", "Win32_Networking", "Win32_Networking_WinSock", "Win32_System_Diagnostics", "Win32_System_Diagnostics_Debug", "Win32_System_Threading"]

network/windows/src/address.rs

@@ -20,7 +20,8 @@ pub struct WindowsAddressAny {
 
 impl Address for WindowsAddressAny {
     fn parse(raw: &str) -> Result<Self, String> {
-        let encoded = raw.encode_utf16().collect::<Vec<_>>();
+        let mut encoded = raw.encode_utf16().collect::<Vec<_>>();
+        encoded.push(0);
         unsafe {
             let mut p = null_mut::<ADDRINFOW>();
 
@@ -37,7 +38,7 @@ impl Address for WindowsAddressAny {
 
             let mut this = Self { native: zeroed() };
 
-            copy_nonoverlapping((*p).ai_addr.cast(), &mut this.native, (*p).ai_addrlen);
+            copy_nonoverlapping::<u8>((*p).ai_addr.cast(), ((&mut this.native) as *mut SOCKADDR_STORAGE).cast(), (*p).ai_addrlen);
 
             FreeAddrInfoW(Some(p));
             return Result::Ok(this);

network/windows/src/eventloop.rs

@@ -16,6 +16,7 @@ use windows::Win32::Networking::WinSock::{
     WSASendTo, WSASocketW,
 };
 use windows::Win32::System::IO::OVERLAPPED;
+use windows::Win32::System::Threading::SleepEx;
 
 pub unsafe fn run_eventloop<Ctx: ServersContext<WindowsAddressKnown>>(ctx: *mut Ctx) {
     let mut heap = Allocator::<IoTask<CallbackData<_>>>::new();
@@ -28,11 +29,13 @@ pub unsafe fn run_eventloop<Ctx: ServersContext<WindowsAddressKnown>>(ctx: *mut
         NonNull::new_unchecked(ctx),
         NonNull::from_mut(&mut heap),
     );
-    socket.receive(&mut recv_task, Some(receiving_done::<Ctx>));
+
+    let mut is_receive_enabled = false;
 
     loop {
         let (id, it) = (*ctx).start_measuring();
 
+        let mut should_recv_being_enabled = false;
         for address in it {
             let mut task = NonNull::from_mut(&mut heap).as_mut().alloc();
             CallbackData::init_send(
@@ -43,7 +46,15 @@ pub unsafe fn run_eventloop<Ctx: ServersContext<WindowsAddressKnown>>(ctx: *mut
             );
 
             socket.send(&mut task, Some(sending_done::<Ctx>));
+            should_recv_being_enabled = true;
         }
+
+        if (!is_receive_enabled && should_recv_being_enabled) {
+            socket.receive(&mut recv_task, Some(receiving_done::<Ctx>));
+            is_receive_enabled = true;
+        }
+
+        SleepEx(1000, true);
     }
 }