Address code review: add fd validation, fix partial write handling, improve error messages

- Add in_fd validation in hio_sendfile() for both nio.c and overlapio.c
- Fix generic sendfile fallback to handle partial writes correctly
- Check sendfile_remain under mutex before unlocking in nio_write
- Improve SSL fallback with better EOF/error distinction
- Add fileno() validation in HTTP handler
- Improve Windows fallback with separate seek/read error handling

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/nio.c

@@ -334,16 +334,26 @@ static ssize_t __nio_sendfile_sys(int out_fd, int in_fd, off_t* offset, size_t c
     }
     return -1;
 #else
-    // Fallback: read + write
+    // Fallback: pread + write (sends one chunk per call to integrate with event loop)
     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;
+    ssize_t total_written = 0;
+    while (total_written < nread) {
+        ssize_t nwrite = write(out_fd, buf + total_written, nread - total_written);
+        if (nwrite < 0) {
+            if (total_written > 0) {
+                *offset += total_written;
+                return total_written;
+            }
+            return -1;
+        }
+        if (nwrite == 0) break;
+        total_written += nwrite;
     }
-    return nwrite;
+    *offset += total_written;
+    return total_written;
 #endif
 }
 
@@ -480,11 +490,12 @@ static void nio_write(hio_t* io) {
         if (nsent == 0 && (io->io_type & HIO_TYPE_SOCK_STREAM)) {
             goto disconnect;
         }
+        int complete = (io->sendfile_remain == 0);
         hrecursive_mutex_unlock(&io->write_mutex);
         if (nsent > 0) {
             __write_cb(io, NULL, nsent);
         }
-        if (io->sendfile_remain == 0) {
+        if (complete) {
             io->sendfile_fd = -1;
         }
         return;
@@ -679,20 +690,30 @@ int hio_sendfile (hio_t* io, int in_fd, off_t offset, size_t length) {
         hloge("hio_sendfile called but fd[%d] already closed!", io->fd);
         return -1;
     }
+    if (in_fd < 0) {
+        hloge("hio_sendfile invalid file descriptor: %d", in_fd);
+        return -1;
+    }
     if (length == 0) return 0;
 
     // SSL: fall back to read + hio_write (sendfile cannot bypass SSL encryption)
+    // NOTE: hio_write is non-blocking and queues data internally,
+    // so this won't block the event loop even for large files.
     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!");
+            if (nread < 0) {
+                hloge("hio_sendfile pread error: %s", strerror(errno));
                 return -1;
             }
+            if (nread == 0) {
+                hlogw("hio_sendfile: unexpected EOF at offset %lld", (long long)cur_offset);
+                break;
+            }
             int nwrite = hio_write(io, buf, nread);
             if (nwrite < 0) return nwrite;
             cur_offset += nread;
@@ -721,9 +742,10 @@ int hio_sendfile (hio_t* io, int in_fd, off_t offset, size_t length) {
             }
         }
         if (nsent > 0) {
+            int complete = (io->sendfile_remain == 0);
             hrecursive_mutex_unlock(&io->write_mutex);
             __write_cb(io, NULL, nsent);
-            if (io->sendfile_remain == 0) {
+            if (complete) {
                 io->sendfile_fd = -1;
                 return 0;
             }

event/overlapio.c

@@ -389,15 +389,19 @@ int hio_sendto (hio_t* io, const void* buf, size_t len, struct sockaddr* addr) {
 
 int hio_sendfile (hio_t* io, int in_fd, off_t offset, size_t length) {
     if (io->closed) return -1;
+    if (in_fd < 0) return -1;
     if (length == 0) return 0;
-    // Fallback: read + hio_write
+    // NOTE: Windows fallback uses read + hio_write.
+    // hio_write is non-blocking (queues via IOCP), so this won't block.
     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;
+        if (_lseeki64(in_fd, cur_offset, SEEK_SET) < 0) return -1;
+        ssize_t nread = _read(in_fd, buf, (unsigned int)to_read);
+        if (nread < 0) return -1;
+        if (nread == 0) break; // EOF
         int nwrite = hio_write(io, buf, nread);
         if (nwrite < 0) return nwrite;
         cur_offset += nread;

http/server/HttpHandler.cpp

@@ -659,8 +659,8 @@ 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
+    } else if (service->limit_rate < 0 && file->fp && fileno(file->fp) >= 0) {
+        // unlimited: use zero-copy sendfile
         int filefd = fileno(file->fp);
         size_t length = resp->content_length;
         writer->EndHeaders();
@@ -677,7 +677,7 @@ int HttpHandler::defaultLargeFileHandler(const std::string &filepath) {
         size_t bufsize = 40960; // 40K
         file->buf.resize(bufsize);
         if (service->limit_rate < 0) {
-            // unlimited: sendFile when writable (fallback when fileno unavailable)
+            // unlimited: sendFile when writable
             writer->onwrite = [this](HBuf* buf) {
                 if (writer->isWriteComplete()) {
                     sendFile();