replace pxl8.sh with Makefile, port client and server to Windows

pxl8d/src/main.rs

@@ -26,7 +26,7 @@ fn get_time_ns() -> u64 {
     static mut FREQ: i64 = 0;
     unsafe {
         if FREQ == 0 {
-            QueryPerformanceFrequency(&mut FREQ);
+            QueryPerformanceFrequency(&raw mut FREQ);
         }
         let mut count: i64 = 0;
         QueryPerformanceCounter(&mut count);

pxl8d/src/transport.rs

@@ -79,6 +79,8 @@ mod sys {
     pub type RawSocket = c_int;
     pub const INVALID_SOCKET: RawSocket = -1;
 
+    pub fn init() {}
+
     pub fn socket() -> RawSocket {
         unsafe { libc::socket(libc::AF_INET, libc::SOCK_DGRAM, 0) }
     }
@@ -139,6 +141,8 @@ mod sys {
     pub type RawSocket = c_int;
     pub const INVALID_SOCKET: RawSocket = -1;
 
+    pub fn init() {}
+
     pub fn socket() -> RawSocket {
         unsafe { libc::socket(libc::AF_INET, libc::SOCK_DGRAM, 0) }
     }
@@ -195,59 +199,66 @@ mod sys {
 
 #[cfg(windows)]
 mod sys {
-    use windows_sys::Win32::Networking::WinSock::*;
+    use windows_sys::Win32::Networking::WinSock as ws;
 
-    pub type RawSocket = SOCKET;
-    pub const INVALID_SOCKET_VAL: RawSocket = INVALID_SOCKET;
+    pub type RawSocket = ws::SOCKET;
+    pub const INVALID_SOCKET: RawSocket = ws::INVALID_SOCKET;
+
+    pub fn init() {
+        unsafe {
+            let mut wsa: ws::WSADATA = core::mem::zeroed();
+            ws::WSAStartup(0x0202, &mut wsa);
+        }
+    }
 
     pub fn socket() -> RawSocket {
-        unsafe { socket(AF_INET as i32, SOCK_DGRAM as i32, 0) }
+        unsafe { ws::socket(ws::AF_INET as i32, ws::SOCK_DGRAM as i32, 0) }
     }
 
     pub fn bind(sock: RawSocket, port: u16) -> i32 {
-        let addr = SOCKADDR_IN {
-            sin_family: AF_INET,
+        let addr = ws::SOCKADDR_IN {
+            sin_family: ws::AF_INET,
             sin_port: port.to_be(),
-            sin_addr: IN_ADDR { S_un: IN_ADDR_0 { S_addr: u32::from_be_bytes([127, 0, 0, 1]).to_be() } },
+            sin_addr: ws::IN_ADDR { S_un: ws::IN_ADDR_0 { S_addr: 0 } },
             sin_zero: [0; 8],
         };
-        unsafe { bind(sock, &addr as *const _ as *const SOCKADDR, core::mem::size_of::<SOCKADDR_IN>() as i32) }
+        unsafe { ws::bind(sock, &addr as *const _ as *const ws::SOCKADDR, core::mem::size_of::<ws::SOCKADDR_IN>() as i32) }
     }
 
     pub fn set_nonblocking(sock: RawSocket) -> i32 {
         let mut nonblocking: u32 = 1;
-        unsafe { ioctlsocket(sock, FIONBIO as i32, &mut nonblocking) }
+        unsafe { ws::ioctlsocket(sock, ws::FIONBIO as i32, &mut nonblocking) }
     }
 
-    pub fn recvfrom(sock: RawSocket, buf: &mut [u8], addr: &mut SOCKADDR_IN) -> i32 {
-        let mut addr_len = core::mem::size_of::<SOCKADDR_IN>() as i32;
+    pub fn recvfrom(sock: RawSocket, buf: &mut [u8], addr: &mut ws::SOCKADDR_IN) -> i32 {
+        let mut addr_len = core::mem::size_of::<ws::SOCKADDR_IN>() as i32;
         unsafe {
-            recvfrom(
+            ws::recvfrom(
                 sock,
                 buf.as_mut_ptr(),
                 buf.len() as i32,
                 0,
-                addr as *mut _ as *mut SOCKADDR,
+                addr as *mut _ as *mut ws::SOCKADDR,
                 &mut addr_len,
             )
         }
     }
 
-    pub fn sendto(sock: RawSocket, buf: &[u8], addr: &SOCKADDR_IN) -> i32 {
+    pub fn sendto(sock: RawSocket, buf: &[u8], addr: &ws::SOCKADDR_IN) -> i32 {
         unsafe {
-            sendto(
+            ws::sendto(
                 sock,
                 buf.as_ptr(),
                 buf.len() as i32,
                 0,
-                addr as *const _ as *const SOCKADDR,
-                core::mem::size_of::<SOCKADDR_IN>() as i32,
+                addr as *const _ as *const ws::SOCKADDR,
+                core::mem::size_of::<ws::SOCKADDR_IN>() as i32,
             )
         }
     }
 
     pub fn close(sock: RawSocket) {
-        unsafe { closesocket(sock) };
+        unsafe { ws::closesocket(sock) };
     }
 }
 
@@ -257,6 +268,7 @@ type SockAddr = libc::sockaddr_in;
 #[cfg(windows)]
 type SockAddr = windows_sys::Win32::Networking::WinSock::SOCKADDR_IN;
 
+
 pub struct Transport {
     client_addr: SockAddr,
     has_client: bool,
@@ -267,6 +279,7 @@ pub struct Transport {
 
 impl Transport {
     pub fn bind(port: u16) -> Option<Self> {
+        sys::init();
         let sock = sys::socket();
         if sock == sys::INVALID_SOCKET {
             return None;