2 files changed, 40 insertions, 24 deletions

diff --git a/examples/networking/echo_server.zc b/examples/networking/echo_server.zc
index 2934923..64c60da 100644
--- a/examples/networking/echo_server.zc
+++ b/examples/networking/echo_server.zc
@@ -4,6 +4,7 @@ import "std/net.zc"
 def SIZE = 1024;
 
 fn main() {
+    raw { setbuf(stdout, NULL); }
     "Starting Echo Server on 127.0.0.1:8080...";
     
     let listener_res = TcpListener::bind("127.0.0.1", 8080);
@@ -13,24 +14,37 @@ fn main() {
     }
 
     let listener = listener_res.unwrap();
-    defer listener.close();
 
     loop {
         let client_res = listener.accept();
         if client_res.is_ok() {
             let stream = client_res.unwrap();
-            defer stream.close();
             
-            let buf = (char*)malloc(SIZE);
-            defer free(buf);
-            let read_res = stream.read(buf, SIZE);
+            "New Connection!";
             
-            if read_res.is_ok() {
+            let buf: char[SIZE];
+            
+            while true {
+                let read_res = stream.read(&buf[0], SIZE);
+                
+                if read_res.is_err() {
+                    !"Read error: {read_res.err}";
+                    break;
+                }
+                
                 let bytes = read_res.unwrap();
-                if bytes > 0 {
-                    stream.write(buf, bytes);
-                    "Echoed {bytes} bytes.";
+                if bytes == 0 {
+                    "Client disconnected.";
+                    break;
                 }
+                
+                let write_res = stream.write(&buf[0], bytes);
+                 if write_res.is_err() {
+                    !"Write error: {write_res.err}";
+                    break;
+                }
+
+                "Echoed {bytes} bytes.";
             }
         }
     }
diff --git a/std/net.zc b/std/net.zc
index d410a4d..826b795 100644
--- a/std/net.zc
+++ b/std/net.zc
@@ -63,26 +63,28 @@ extern fn _z_net_write(fd: int, buf: const char*, n: usize) -> isize;
 
 
 struct TcpStream {
-    fd: int;
+    handle: int;
 }
 
+extern fn strerror(errnum: int) -> char*;
+
 impl TcpStream {
     fn read(self, buf: char*, len: usize) -> Result<usize> {
-        let n = read(self.fd, (void*)buf, len);
-        if (n < 0) return Result<usize>::Err("Read failed");
+        let n = read(self.handle - 1, (void*)buf, len);
+        if (n < 0) 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.fd, buf, len);
+        let n = _z_net_write(self.handle - 1, buf, len);
         if (n < 0) return Result<usize>::Err("Write failed");
         return Result<usize>::Ok((usize)n);
     }
     
     fn close(self) {
-        if (self.fd >= 0) {
-            close(self.fd);
-            self.fd = -1;
+        if (self.handle > 0) {
+            close(self.handle - 1);
+            self.handle = 0;
         }
     }
 
@@ -94,7 +96,7 @@ impl TcpStream {
         if (res == -1) { close(fd); return Result<TcpStream>::Err("Invalid address"); }
         if (res == -2) { close(fd); return Result<TcpStream>::Err("Connection failed"); }
         
-        return Result<TcpStream>::Ok(TcpStream { fd: fd });
+        return Result<TcpStream>::Ok(TcpStream { handle: fd + 1 });
     }
 }
 
@@ -105,7 +107,7 @@ impl Drop for TcpStream {
 }
 
 struct TcpListener {
-    fd: int;
+    handle: int;
 }
 
 impl TcpListener {
@@ -118,19 +120,19 @@ impl TcpListener {
         if (res == -2) { close(fd); return Result<TcpListener>::Err("Bind failed"); }
         if (res == -3) { close(fd); return Result<TcpListener>::Err("Listen failed"); }
         
-        return Result<TcpListener>::Ok(TcpListener { fd: fd });
+        return Result<TcpListener>::Ok(TcpListener { handle: fd + 1 });
     }
     
     fn accept(self) -> Result<TcpStream> {
-        let client_fd = _z_net_accept(self.fd);
+        let client_fd = _z_net_accept(self.handle - 1);
         if (client_fd < 0) return Result<TcpStream>::Err("Accept failed");
-        return Result<TcpStream>::Ok(TcpStream { fd: client_fd });
+        return Result<TcpStream>::Ok(TcpStream { handle: client_fd + 1 });
     }
     
     fn close(self) {
-        if (self.fd >= 0) {
-            close(self.fd);
-            self.fd = -1;
+        if (self.handle > 0) {
+            close(self.handle - 1);
+            self.handle = 0;
         }
     }
 }