--- a/seobeo/s_linux_network.c	Sat Sep 27 16:23:04 2025 -0700
+++ b/seobeo/s_linux_network.c	Mon Sep 29 16:00:44 2025 -0700
@@ -110,12 +110,12 @@
   return p_handle;
 }
 
-Seobeo_PHandle Seobeo_Stream_Handle_Accept(Seobeo_PHandle server_h)
+Seobeo_PHandle Seobeo_Stream_Handle_Accept(Seobeo_PHandle p_server_handle)
 {
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof addr;
   char client_inet_addr[INET6_ADDRSTRLEN];
-  int client_fd = accept(server_h->socket,
+  int client_fd = accept(p_server_handle->socket,
                          (struct sockaddr*)&addr,
                          &addrlen);
   inet_ntop(
@@ -128,45 +128,46 @@
     return NULL;
   }
 
-  Seobeo_PHandle h = malloc(sizeof *h);
+  Seobeo_PHandle p_client_handle = malloc(sizeof *p_client_handle);
 
-  h->socket               = client_fd;
-  h->host                 = strdup(client_inet_addr);
-  h->port                 = NULL;
+  p_client_handle->socket               = client_fd;
+  p_client_handle->host                 = strdup(client_inet_addr);
+  p_client_handle->port                 = NULL;
 
-  h->read_buffer_capacity = server_h->read_buffer_capacity;
-  h->read_buffer_len      = 0;
-  h->read_buffer          = malloc(h->read_buffer_capacity);
+  p_client_handle->read_buffer_capacity = p_server_handle->read_buffer_capacity;
+  p_client_handle->read_buffer_len      = 0;
+  p_client_handle->read_buffer          = malloc(p_client_handle->read_buffer_capacity);
 
-  h->write_buffer_capacity = server_h->write_buffer_capacity;
-  h->write_buffer_len      = 0;
-  h->write_buffer          = malloc(h->write_buffer_capacity);
+  p_client_handle->write_buffer_capacity = p_server_handle->write_buffer_capacity;
+  p_client_handle->write_buffer_len      = 0;
+  p_client_handle->write_buffer          = malloc(p_client_handle->write_buffer_capacity);
 
-  return h;
+  return p_client_handle;
 }
 
-void Seobeo_Handle_Destroy(Seobeo_PHandle h)
+void Seobeo_Handle_Destroy(Seobeo_PHandle p_handle)
 {
-  close(h->socket);
-  free(h->host);
-  free(h->port);
-  free(h->read_buffer);
-  free(h->write_buffer);
-  free(h->file);
-  free(h->text_copy);
-  free(h->file_name);
-  free(h);
+  close(p_handle->socket);
+  free(p_handle->host);
+  free(p_handle->port);
+  free(p_handle->read_buffer);
+  free(p_handle->write_buffer);
+  free(p_handle->file);
+  free(p_handle->text_copy);
+  free(p_handle->file_name);
+  free(p_handle);
 }
 
-int Seobeo_Handle_Flush(Seobeo_PHandle h)
+int Seobeo_Handle_Flush(Seobeo_PHandle p_handle)
 {
-  uint32 total = h->write_buffer_len;
+  uint32 total = p_handle->write_buffer_len;
   uint32 sent  = 0;
 
-  while (sent < total) {
+  while (sent < total)
+  {
     ssize_t n = write(
-      h->socket,
-      h->write_buffer + sent,
+      p_handle->socket,
+      p_handle->write_buffer + sent,
       total - sent
     );
     if (n < 0) {
@@ -177,28 +178,29 @@
     sent += (uint32)n;
   }
 
-  h->write_buffer_len = 0;
+  p_handle->write_buffer_len = 0;
   return 0;
 }
 
-
-int Seobeo_Handle_QueueData(Seobeo_PHandle h, const uint8_t *data, uint32_t data_size)
+int Seobeo_Handle_Queue(Seobeo_PHandle p_handle, const uint8_t *data, uint32_t data_size)
 {
-  if (h->write_buffer_len + data_size > h->write_buffer_capacity) {
-    int rc = Seobeo_Handle_Flush(h);
+  if (p_handle->write_buffer_len + data_size > p_handle->write_buffer_capacity)
+  {
+    int rc = Seobeo_Handle_Flush(p_handle);
     if (rc < 0) return -1;
     if (rc > 0) return 1;
   }
 
-  if (data_size > h->write_buffer_capacity)
+  if (data_size > p_handle->write_buffer_capacity)
   {
     uint32_t offset = 0;
     while (offset < data_size)
     {
-      ssize_t n = write(h->socket,
+      ssize_t n = write(p_handle->socket,
                 data + offset,
                 data_size - offset);
-      if (n < 0) {
+      if (n < 0)
+      {
         if (errno == EINTR)  continue;
         if (errno == EAGAIN) return 1;
         return -1;
@@ -208,13 +210,55 @@
     return 0;
   }
 
-  memcpy(h->write_buffer + h->write_buffer_len,
+  memcpy(p_handle->write_buffer + p_handle->write_buffer_len,
          data,
          data_size);
-  h->write_buffer_len += data_size;
+  p_handle->write_buffer_len += data_size;
   return 0;
 }
 
+int Seobeo_Handle_Read(Seobeo_PHandle p_handle)
+{
+  // How many bytes we can still read into the buffer
+  uint32 free_space = p_handle->read_buffer_capacity - p_handle->read_buffer_len;
+  if (free_space == 0)
+    return -1;
+
+  ssize_t n = read(
+    p_handle->socket,
+    p_handle->read_buffer + p_handle->read_buffer_len,
+    free_space
+  );
+  if (n < 0) {
+    if (errno == EINTR)    return Seobeo_Handle_Read(p_handle);
+    if (errno == EAGAIN)   return 0;   // no data available right now
+    return -1;                        // fatal error
+  }
+  if (n == 0) {
+    return -2;   // peer closed the connection
+  }
+
+  p_handle->read_buffer_len += (uint32)n;
+  return (int)n;  // number of bytes read
+}
+
+void Seobeo_Handle_Consume(Seobeo_PHandle p_handle, uint32 consumed)
+{
+  if (consumed >= p_handle->read_buffer_len)
+  {
+    p_handle->read_buffer_len = 0;
+    return;
+  }
+
+  // Slide remaining bytes to the front
+  memmove(
+    p_handle->read_buffer,
+    p_handle->read_buffer + consumed,
+    p_handle->read_buffer_len - consumed
+  );
+  p_handle->read_buffer_len -= consumed;
+}
+
 void *Seobeo_GetIP4OrIP6(struct sockaddr *sa)
 {
   if (sa->sa_family == AF_INET)