use pointer directly

Author: saviorand

external/libc.mojo

@@ -633,8 +633,28 @@ fn connect(socket: c_int, address: UnsafePointer[sockaddr], address_len: socklen
     ](socket, address, address_len)
 
 
+# fn recv(
+#     socket: c_int, buffer: UnsafePointer[c_void], length: c_size_t, flags: c_int
+# ) -> c_ssize_t:
+#     """Libc POSIX `recv` function
+#     Reference: https://man7.org/linux/man-pages/man3/recv.3p.html
+#     Fn signature: ssize_t recv(int socket, void *buffer, size_t length, int flags).
+#     """
+#     return external_call[
+#         "recv",
+#         c_ssize_t,  # FnName, RetType
+#         c_int,
+#         UnsafePointer[c_void],
+#         c_size_t,
+#         c_int,  # Args
+#     ](socket, buffer, length, flags)
+
+
 fn recv(
-    socket: c_int, buffer: UnsafePointer[c_void], length: c_size_t, flags: c_int
+    socket: c_int,
+    buffer: DTypePointer[DType.uint8],
+    length: c_size_t,
+    flags: c_int,
 ) -> c_ssize_t:
     """Libc POSIX `recv` function
     Reference: https://man7.org/linux/man-pages/man3/recv.3p.html
@@ -644,12 +664,11 @@ fn recv(
         "recv",
         c_ssize_t,  # FnName, RetType
         c_int,
-        UnsafePointer[c_void],
+        DTypePointer[DType.uint8],
         c_size_t,
         c_int,  # Args
     ](socket, buffer, length, flags)
 
-
 fn send(
     socket: c_int, buffer: UnsafePointer[c_void], length: c_size_t, flags: c_int
 ) -> c_ssize_t:

lightbug_http/net.mojo

@@ -14,7 +14,7 @@ from external.libc import (
     inet_ntop
 )
 
-alias default_buffer_size = 8200
+alias default_buffer_size = 4096
 alias default_tcp_keep_alive = Duration(15 * 1000 * 1000 * 1000)  # 15 seconds
 
 

lightbug_http/sys/net.mojo

@@ -217,14 +217,14 @@ struct SysConnection(Connection):
         self.fd = fd
 
     fn read(self, inout buf: Bytes) raises -> Int:
-        var new_buf = UnsafePointer[UInt8]().alloc(default_buffer_size)
-        var bytes_recv = recv(self.fd, new_buf, default_buffer_size, 0)
+        var bytes_recv = recv(self.fd, DTypePointer[DType.uint8](buf.unsafe_ptr()).offset(buf.size), buf.capacity - buf.size, 0)
         if bytes_recv == -1:
             return 0
+        buf.size += bytes_recv
         if bytes_recv == 0:
             return 0
-        var bytes_str = String(new_buf.bitcast[UInt8](), bytes_recv + 1)
-        buf = bytes(bytes_str, pop=False)
+        if bytes_recv < buf.capacity:
+            return bytes_recv
         return bytes_recv
 
     fn write(self, msg: String) raises -> Int:

lightbug_http/sys/server.mojo

@@ -149,7 +149,6 @@ struct SysServer:
 
         while True:
             var conn = self.ln.accept()
-            # while True:
             self.serve_connection(conn, handler)
 
     fn serve_connection[T: HTTPService](inout self, conn: SysConnection, handler: T) raises -> None:
@@ -163,14 +162,14 @@ struct SysServer:
         Raises:
         If there is an error while serving the connection.
         """
-        var b = Bytes()
-        _ = conn.read(b)
-        if len(b) == 0:
+        var b = Bytes(capacity=default_buffer_size)
+        var bytes_recv = conn.read(b) 
+        if bytes_recv == 0:
             conn.close()
             return
 
-        var buf = buffer.new_buffer(b)
-        var reader = Reader(buf)
+        var buf = buffer.new_buffer(b^)
+        var reader = Reader(buf^)
 
         var error = Error()
 
@@ -180,57 +179,67 @@ struct SysServer:
 
         var req_number = 0
 
-        # while True:
-        req_number += 1
+        while True:
+            req_number += 1
 
-        var first_byte = reader.peek(1)
-        if len(first_byte) == 0:
-            error = Error("Failed to read first byte from connection")
-        
-        var header = RequestHeader()
-        var first_line_and_headers_len = 0
-        try:
-            first_line_and_headers_len = header.parse_raw(reader)
-        except e:
-            error = Error("Failed to parse request headers: " + e.__str__())
-
-        var uri = URI(self.address() + String(header.request_uri()))
-        try:
-            uri.parse()
-        except e:
-            error = Error("Failed to parse request line:" + e.__str__())
-        
-        if header.content_length() > 0:
-            if max_request_body_size > 0 and header.content_length() > max_request_body_size:
-                error = Error("Request body too large")
+            if req_number > 1:
+                var b = Bytes(capacity=default_buffer_size)
+                var bytes_recv = conn.read(b)
+                if bytes_recv == 0:
+                    conn.close()
+                    break
+                buf = buffer.new_buffer(b^)
+                reader = Reader(buf^)
+
+
+            var first_byte = reader.peek(1)
+            if len(first_byte) == 0:
+                error = Error("Failed to read first byte from connection")
+            
+            var header = RequestHeader()
+            var first_line_and_headers_len = 0
+            try:
+                first_line_and_headers_len = header.parse_raw(reader)
+            except e:
+                error = Error("Failed to parse request headers: " + e.__str__())
+
+            var uri = URI(self.address() + String(header.request_uri()))
+            try:
+                uri.parse()
+            except e:
+                error = Error("Failed to parse request line:" + e.__str__())
+            
+            if header.content_length() > 0:
+                if max_request_body_size > 0 and header.content_length() > max_request_body_size:
+                    error = Error("Request body too large")
+            
+            var request = HTTPRequest(
+                    uri,
+                    Bytes(),
+                    header,
+                )
+
+            try:
+                request.read_body(reader, header.content_length(), first_line_and_headers_len, max_request_body_size)
+            except e:
+                error = Error("Failed to read request body: " + e.__str__())
 
             # var remaining_body = Bytes()
             # var remaining_len = header.content_length() - (len(request_body) + 1)
             # while remaining_len > 0:
             #     var read_len = conn.read(remaining_body)
             #     buf.extend(remaining_body)
             #     remaining_len -= read_len
-        
-        var request = HTTPRequest(
-                uri,
-                Bytes(),
-                header,
-            )
-
-        try:
-            request.read_body(reader, header.content_length(), first_line_and_headers_len, max_request_body_size)
-        except e:
-            error = Error("Failed to read request body: " + e.__str__())
-        
-        var res = handler.func(request)
-        
-        # if not self.tcp_keep_alive:
-        _ = res.set_connection_close()
-        
-        var res_encoded = encode(res)
+            
+            var res = handler.func(request)
+            
+            if not self.tcp_keep_alive:
+                _ = res.set_connection_close()
+            
+            var res_encoded = encode(res)
 
-        _ = conn.write(res_encoded)
+            _ = conn.write(res_encoded)
 
-        # if not self.tcp_keep_alive:
-        conn.close()
-        # break
+        if not self.tcp_keep_alive:
+            conn.close()
+            return

test.mojo

@@ -9,6 +9,6 @@ struct MyPrinter(HTTPService):
 
 
 fn main() raises:
-    var server = SysServer()
+    var server = SysServer(tcp_keep_alive=True)
     var handler = MyPrinter()
     server.listen_and_serve("0.0.0.0:8080", handler)