Add hio_sendfile() API for zero-copy file transfer using sendfile(2)

Implements:
- Platform-abstracted sendfile in nio.c (Linux sendfile, macOS/FreeBSD sendfile, generic pread+write fallback)
- hio_sendfile() public API in hloop.h with write queue integration
- Sendfile state tracking in hio_t (sendfile_fd, sendfile_offset, sendfile_remain)
- SSL fallback using pread + hio_write
- Windows fallback in overlapio.c
- Integration into HTTP large file handler for unlimited rate mode
- hio_write_bufsize accounts for sendfile remaining bytes

Co-authored-by: ithewei <26049660+ithewei@users.noreply.github.com>
Agent-Logs-Url: https://github.com/ithewei/libhv/sessions/e59504ed-e745-410d-a8ab-e99946d80a3c

Author: Copilot

event/hevent.c

@@ -77,6 +77,9 @@ void hio_init(hio_t* io) {
     // write_queue_init(&io->write_queue, 4);
 
     hrecursive_mutex_init(&io->write_mutex);
+    io->sendfile_fd = -1;
+    io->sendfile_offset = 0;
+    io->sendfile_remain = 0;
 }
 
 void hio_ready(hio_t* io) {
@@ -752,7 +755,7 @@ void hio_set_max_write_bufsize(hio_t* io, uint32_t size) {
 }
 
 size_t hio_write_bufsize(hio_t* io) {
-    return io->write_bufsize;
+    return io->write_bufsize + io->sendfile_remain;
 }
 
 int hio_read_once (hio_t* io) {

event/hevent.h

@@ -175,6 +175,10 @@ struct hio_s {
     char*       hostname;   // for hssl_set_sni_hostname
     // context
     void*       ctx; // for hio_context / hio_set_context
+    // sendfile
+    int         sendfile_fd;        // file descriptor for sendfile, -1 when inactive
+    off_t       sendfile_offset;    // current offset in file
+    size_t      sendfile_remain;    // remaining bytes to send
 // private:
 #if defined(EVENT_POLL) || defined(EVENT_KQUEUE)
     int         event_index[2]; // for poll,kqueue

event/hloop.h

@@ -380,6 +380,15 @@ HV_EXPORT int hio_read_remain(hio_t* io);
 HV_EXPORT int hio_write  (hio_t* io, const void* buf, size_t len);
 HV_EXPORT int hio_sendto (hio_t* io, const void* buf, size_t len, struct sockaddr* addr);
 
+// NOTE: hio_sendfile uses zero-copy sendfile(2) on Linux, sendfile(2) on macOS/FreeBSD.
+// Falls back to read+write for SSL connections and unsupported platforms.
+// @param in_fd: file descriptor of the file to send from
+// @param offset: starting offset in the file
+// @param length: number of bytes to send
+// @return 0 on success (async operation started), -1 on error
+// hwrite_cb is called as data is sent. When complete, write_queue is empty.
+HV_EXPORT int hio_sendfile(hio_t* io, int in_fd, off_t offset, size_t length);
+
 // NOTE: hio_close is thread-safe, hio_close_async will be called actually in other thread.
 // hio_del(io, HV_RDWR) => close => hclose_cb
 HV_EXPORT int hio_close  (hio_t* io);

event/nio.c

@@ -7,6 +7,15 @@
 #include "herr.h"
 #include "hthread.h"
 
+#ifdef OS_LINUX
+#include <sys/sendfile.h>
+#endif
+#if defined(OS_DARWIN) || defined(OS_FREEBSD)
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+#endif
+
 static void __connect_timeout_cb(htimer_t* timer) {
     hio_t* io = (hio_t*)timer->privdata;
     if (io) {
@@ -304,6 +313,50 @@ static int __nio_write(hio_t* io, const void* buf, int len, struct sockaddr* add
     return nwrite;
 }
 
+// Platform-abstracted sendfile: returns bytes sent, -1 on error
+static ssize_t __nio_sendfile_sys(int out_fd, int in_fd, off_t* offset, size_t count) {
+#ifdef OS_LINUX
+    return sendfile(out_fd, in_fd, offset, count);
+#elif defined(OS_DARWIN)
+    off_t len = count;
+    int ret = sendfile(in_fd, out_fd, *offset, &len, NULL, 0);
+    if (ret == 0 || (ret == -1 && errno == EAGAIN && len > 0)) {
+        *offset += len;
+        return (ssize_t)len;
+    }
+    return -1;
+#elif defined(OS_FREEBSD)
+    off_t sbytes = 0;
+    int ret = sendfile(in_fd, out_fd, *offset, count, NULL, &sbytes, 0);
+    if (ret == 0 || (ret == -1 && errno == EAGAIN && sbytes > 0)) {
+        *offset += sbytes;
+        return (ssize_t)sbytes;
+    }
+    return -1;
+#else
+    // Fallback: read + write
+    char buf[65536];
+    size_t to_read = count < sizeof(buf) ? count : sizeof(buf);
+    ssize_t nread = pread(in_fd, buf, to_read, *offset);
+    if (nread <= 0) return nread;
+    ssize_t nwrite = write(out_fd, buf, nread);
+    if (nwrite > 0) {
+        *offset += nwrite;
+    }
+    return nwrite;
+#endif
+}
+
+// Try sendfile for the current io, called with write_mutex held
+// Returns: > 0 bytes sent, 0 if nothing sent, < 0 on error
+static ssize_t __nio_sendfile(hio_t* io) {
+    ssize_t nsent = __nio_sendfile_sys(io->fd, io->sendfile_fd, &io->sendfile_offset, io->sendfile_remain);
+    if (nsent > 0) {
+        io->sendfile_remain -= nsent;
+    }
+    return nsent;
+}
+
 static void nio_read(hio_t* io) {
     // printd("nio_read fd=%d\n", io->fd);
     void* buf;
@@ -361,6 +414,10 @@ static void nio_write(hio_t* io) {
     hrecursive_mutex_lock(&io->write_mutex);
 write:
     if (write_queue_empty(&io->write_queue)) {
+        // Check for pending sendfile after write queue is drained
+        if (io->sendfile_fd >= 0 && io->sendfile_remain > 0) {
+            goto do_sendfile;
+        }
         hrecursive_mutex_unlock(&io->write_mutex);
         if (io->close) {
             io->close = 0;
@@ -407,6 +464,32 @@ static void nio_write(hio_t* io) {
     }
     hrecursive_mutex_unlock(&io->write_mutex);
     return;
+
+do_sendfile:
+    {
+        ssize_t nsent = __nio_sendfile(io);
+        if (nsent < 0) {
+            err = socket_errno();
+            if (err == EAGAIN || err == EINTR) {
+                hrecursive_mutex_unlock(&io->write_mutex);
+                return;
+            }
+            io->error = err;
+            goto write_error;
+        }
+        if (nsent == 0 && (io->io_type & HIO_TYPE_SOCK_STREAM)) {
+            goto disconnect;
+        }
+        hrecursive_mutex_unlock(&io->write_mutex);
+        if (nsent > 0) {
+            __write_cb(io, NULL, nsent);
+        }
+        if (io->sendfile_remain == 0) {
+            io->sendfile_fd = -1;
+        }
+        return;
+    }
+
 write_error:
 disconnect:
     hrecursive_mutex_unlock(&io->write_mutex);
@@ -426,9 +509,10 @@ static void hio_handle_events(hio_t* io) {
     }
 
     if ((io->events & HV_WRITE) && (io->revents & HV_WRITE)) {
-        // NOTE: del HV_WRITE, if write_queue empty
+        // NOTE: del HV_WRITE, if write_queue empty and no pending sendfile
         hrecursive_mutex_lock(&io->write_mutex);
-        if (write_queue_empty(&io->write_queue)) {
+        if (write_queue_empty(&io->write_queue) &&
+            !(io->sendfile_fd >= 0 && io->sendfile_remain > 0)) {
             hio_del(io, HV_WRITE);
         }
         hrecursive_mutex_unlock(&io->write_mutex);
@@ -590,6 +674,72 @@ int hio_sendto (hio_t* io, const void* buf, size_t len, struct sockaddr* addr) {
     return hio_write4(io, buf, len, addr ? addr : io->peeraddr);
 }
 
+int hio_sendfile (hio_t* io, int in_fd, off_t offset, size_t length) {
+    if (io->closed) {
+        hloge("hio_sendfile called but fd[%d] already closed!", io->fd);
+        return -1;
+    }
+    if (length == 0) return 0;
+
+    // SSL: fall back to read + hio_write (sendfile cannot bypass SSL encryption)
+    if (io->io_type == HIO_TYPE_SSL) {
+        char buf[65536];
+        off_t cur_offset = offset;
+        size_t remaining = length;
+        while (remaining > 0) {
+            size_t to_read = remaining < sizeof(buf) ? remaining : sizeof(buf);
+            ssize_t nread = pread(in_fd, buf, to_read, cur_offset);
+            if (nread <= 0) {
+                hloge("hio_sendfile pread error!");
+                return -1;
+            }
+            int nwrite = hio_write(io, buf, nread);
+            if (nwrite < 0) return nwrite;
+            cur_offset += nread;
+            remaining -= nread;
+        }
+        return 0;
+    }
+
+    hrecursive_mutex_lock(&io->write_mutex);
+
+    io->sendfile_fd = in_fd;
+    io->sendfile_offset = offset;
+    io->sendfile_remain = length;
+
+    // If write queue is empty, try sendfile immediately
+    if (write_queue_empty(&io->write_queue)) {
+        ssize_t nsent = __nio_sendfile(io);
+        if (nsent < 0) {
+            int err = socket_errno();
+            if (err != EAGAIN && err != EINTR) {
+                io->error = err;
+                io->sendfile_fd = -1;
+                hrecursive_mutex_unlock(&io->write_mutex);
+                hio_close_async(io);
+                return -1;
+            }
+        }
+        if (nsent > 0) {
+            hrecursive_mutex_unlock(&io->write_mutex);
+            __write_cb(io, NULL, nsent);
+            if (io->sendfile_remain == 0) {
+                io->sendfile_fd = -1;
+                return 0;
+            }
+            hrecursive_mutex_lock(&io->write_mutex);
+        }
+    }
+
+    // If still remaining, register for writable event
+    if (io->sendfile_remain > 0) {
+        hio_add(io, hio_handle_events, HV_WRITE);
+    }
+
+    hrecursive_mutex_unlock(&io->write_mutex);
+    return 0;
+}
+
 int hio_close (hio_t* io) {
     if (io->closed) return 0;
     if (io->destroy == 0 && hv_gettid() != io->loop->tid) {
@@ -611,6 +761,8 @@ int hio_close (hio_t* io) {
         return 0;
     }
     io->closed = 1;
+    io->sendfile_fd = -1;
+    io->sendfile_remain = 0;
     hrecursive_mutex_unlock(&io->write_mutex);
 
     hio_done(io);

event/overlapio.c

@@ -387,6 +387,25 @@ int hio_sendto (hio_t* io, const void* buf, size_t len, struct sockaddr* addr) {
     return hio_write4(io, buf, len, addr ? addr : io->peeraddr);
 }
 
+int hio_sendfile (hio_t* io, int in_fd, off_t offset, size_t length) {
+    if (io->closed) return -1;
+    if (length == 0) return 0;
+    // Fallback: read + hio_write
+    char buf[65536];
+    off_t cur_offset = offset;
+    size_t remaining = length;
+    while (remaining > 0) {
+        size_t to_read = remaining < sizeof(buf) ? remaining : sizeof(buf);
+        ssize_t nread = _lseeki64(in_fd, cur_offset, SEEK_SET) >= 0 ? _read(in_fd, buf, (unsigned int)to_read) : -1;
+        if (nread <= 0) return -1;
+        int nwrite = hio_write(io, buf, nread);
+        if (nwrite < 0) return nwrite;
+        cur_offset += nread;
+        remaining -= nread;
+    }
+    return 0;
+}
+
 int hio_close (hio_t* io) {
     if (io->closed) return 0;
     io->closed = 1;

http/server/HttpHandler.cpp

@@ -659,11 +659,25 @@ int HttpHandler::defaultLargeFileHandler(const std::string &filepath) {
         // forbidden to send large file
         resp->content_length = 0;
         resp->status_code = HTTP_STATUS_FORBIDDEN;
+    } else if (service->limit_rate < 0 && file->fp) {
+        // unlimited: use zero-copy sendfile if possible
+        int filefd = fileno(file->fp);
+        size_t length = resp->content_length;
+        writer->EndHeaders();
+        writer->onwrite = [this](HBuf* buf) {
+            if (writer->isWriteComplete()) {
+                resp->content_length = 0;
+                writer->End();
+                closeFile();
+            }
+        };
+        hio_sendfile(io, filefd, 0, length);
+        return HTTP_STATUS_UNFINISHED;
     } else {
         size_t bufsize = 40960; // 40K
         file->buf.resize(bufsize);
         if (service->limit_rate < 0) {
-            // unlimited: sendFile when writable
+            // unlimited: sendFile when writable (fallback when fileno unavailable)
             writer->onwrite = [this](HBuf* buf) {
                 if (writer->isWriteComplete()) {
                     sendFile();