1 files changed, 62 insertions, 36 deletions

diff --git a/std/net.zc b/std/net.zc
index 826b795..dce1a01 100644
--- a/std/net.zc
+++ b/std/net.zc
@@ -14,9 +14,9 @@ def Z_AF_INET = 2;
 def Z_SOCK_STREAM = 1;
 
 // Direct externs for simple socket functions
-extern fn socket(domain: int, type: int, proto: int) -> int;
-extern fn close(fd: int) -> int;
-extern fn read(fd: int, buf: void*, count: usize) -> isize;
+extern fn socket(domain: c_int, type: c_int, proto: c_int) -> c_int;
+extern fn close(fd: c_int) -> c_int;
+extern fn read(fd: c_int, buf: void*, count: usize) -> isize;
 
 // Minimal raw block: required for struct sockaddr_in usage
 // These functions encapsulate sockaddr_in setup because the struct layout
@@ -56,47 +56,63 @@ raw {
     }
 }
 
-extern fn _z_net_bind(fd: int, host: const char*, port: int) -> int;
-extern fn _z_net_connect(fd: int, host: const char*, port: int) -> int;
-extern fn _z_net_accept(fd: int) -> int;
-extern fn _z_net_write(fd: int, buf: const char*, n: usize) -> isize;
+extern fn _z_net_bind(fd: c_int, host: const char*, port: c_int) -> c_int;
+extern fn _z_net_connect(fd: c_int, host: const char*, port: c_int) -> c_int;
+extern fn _z_net_accept(fd: c_int) -> c_int;
+extern fn _z_net_write(fd: c_int, buf: const char*, n: usize) -> isize;
 
 
 struct TcpStream {
-    handle: int;
+    handle: c_int;
 }
 
-extern fn strerror(errnum: int) -> char*;
+extern fn strerror(errnum: c_int) -> char*;
 
 impl TcpStream {
     fn read(self, buf: char*, len: usize) -> Result<usize> {
         let n = read(self.handle - 1, (void*)buf, len);
-        if (n < 0) return Result<usize>::Err(strerror(errno));
+        let zero: c_int = 0;
+        if (n < (isize)zero) return Result<usize>::Err(strerror(errno));
         return Result<usize>::Ok((usize)n);
     }
     
-    fn write(self, buf: char*, len: usize) -> Result<usize> {
-        let n = _z_net_write(self.handle - 1, buf, len);
-        if (n < 0) return Result<usize>::Err("Write failed");
+    fn write(self, buf: u8*, len: usize) -> Result<usize> {
+        let one: c_int = 1;
+        let n: isize = _z_net_write(self.handle - one, buf, len);
+        let zero: isize = 0;
+        if (n < zero) return Result<usize>::Err("Write failed");
         return Result<usize>::Ok((usize)n);
     }
     
     fn close(self) {
-        if (self.handle > 0) {
-            close(self.handle - 1);
-            self.handle = 0;
+        let zero: c_int = 0;
+        if (self.handle > zero) {
+            let one: c_int = 1;
+            close(self.handle - one);
+            self.handle = zero;
         }
     }
 
-    fn connect(host: char*, port: int) -> Result<TcpStream> {
-        let fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0);
-        if (fd < 0) return Result<TcpStream>::Err("Failed to create socket");
+    fn connect(host: char*, port: c_int) -> Result<TcpStream> {
+        let zero: c_int = 0;
+        let fd = socket(Z_AF_INET, Z_SOCK_STREAM, zero);
+        if (fd < zero) return Result<TcpStream>::Err("Failed to create socket");
+        
+        // C constants like -1
+        let neg_one: c_int = -1;
         
         let res = _z_net_connect(fd, host, port);
-        if (res == -1) { close(fd); return Result<TcpStream>::Err("Invalid address"); }
-        if (res == -2) { close(fd); return Result<TcpStream>::Err("Connection failed"); }
+        if (res == neg_one) { close(fd); return Result<TcpStream>::Err("Invalid address"); }
+        // _z_net_connect might return -2? The original code had it.
+        // Assuming -2 is also possible... check implementation or just assume logic was correct.
+        // But wait, the original code had:
+        // if (res == -1) ... if (res == -2) ...
+        // I will keep it but cast strict.
+        let neg_two: c_int = -2;
+        if (res == neg_two) { close(fd); return Result<TcpStream>::Err("Connection failed"); }
         
-        return Result<TcpStream>::Ok(TcpStream { handle: fd + 1 });
+        let one: c_int = 1;
+        return Result<TcpStream>::Ok(TcpStream { handle: fd + one });
     }
 }
 
@@ -107,32 +123,42 @@ impl Drop for TcpStream {
 }
 
 struct TcpListener {
-    handle: int;
+    handle: c_int;
 }
 
 impl TcpListener {
-    fn bind(host: char*, port: int) -> Result<TcpListener> {
-        let fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0);
-        if (fd < 0) return Result<TcpListener>::Err("Failed to create socket");
+    fn bind(host: char*, port: c_int) -> Result<TcpListener> {
+        let zero: c_int = 0;
+        let fd = socket(Z_AF_INET, Z_SOCK_STREAM, zero);
+        if (fd < zero) return Result<TcpListener>::Err("Failed to create socket");
         
         let res = _z_net_bind(fd, host, port);
-        if (res == -1) { close(fd); return Result<TcpListener>::Err("Invalid address"); }
-        if (res == -2) { close(fd); return Result<TcpListener>::Err("Bind failed"); }
-        if (res == -3) { close(fd); return Result<TcpListener>::Err("Listen failed"); }
+        let neg_one: c_int = -1;
+        let neg_two: c_int = -2;
+        let neg_three: c_int = -3;
+        
+        if (res == neg_one) { close(fd); return Result<TcpListener>::Err("Invalid address"); }
+        if (res == neg_two) { close(fd); return Result<TcpListener>::Err("Bind failed"); }
+        if (res == neg_three) { close(fd); return Result<TcpListener>::Err("Listen failed"); }
         
-        return Result<TcpListener>::Ok(TcpListener { handle: fd + 1 });
+        let one: c_int = 1;
+        return Result<TcpListener>::Ok(TcpListener { handle: fd + one });
     }
     
     fn accept(self) -> Result<TcpStream> {
-        let client_fd = _z_net_accept(self.handle - 1);
-        if (client_fd < 0) return Result<TcpStream>::Err("Accept failed");
-        return Result<TcpStream>::Ok(TcpStream { handle: client_fd + 1 });
+        let one: c_int = 1;
+        let client_fd = _z_net_accept(self.handle - one);
+        let zero: c_int = 0;
+        if (client_fd < zero) return Result<TcpStream>::Err("Accept failed");
+        return Result<TcpStream>::Ok(TcpStream { handle: client_fd + one });
     }
     
     fn close(self) {
-        if (self.handle > 0) {
-            close(self.handle - 1);
-            self.handle = 0;
+        let zero: c_int = 0;
+        if (self.handle > zero) {
+            let one: c_int = 1;
+            close(self.handle - one);
+            self.handle = zero;
         }
     }
 }