/* The naive approach — works, but inefficient for large files */
char buf[4096];
ssize_t n;

while ((n = read(diskfilefd, buf, sizeof(buf))) > 0) {
    write(sockfd, buf, n);
}

Why Is the Read-Write Loop Slow?

Steps 2 and 3 are the problem. Every time we loop, data travels from kernel to user space and back to kernel space again. This means:

The Solution — sendfile() Zero-Copy Transfer

sendfile() solves this by transferring data directly inside the kernel — from the file’s page cache to the socket’s send buffer — without ever copying it into user space. This is called a zero-copy transfer from the application’s perspective.

The sendfile() API

#include <sys/sendfile.h>

ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
/* Returns: number of bytes transferred, or -1 on error */

Basic Usage — Send an Entire File

#include <sys/sendfile.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

/*
 * Send the entire contents of 'filename' through 'sockfd'.
 * Returns 0 on success, -1 on error.
 */
int send_file(int sockfd, const char *filename)
{
    int filefd;
    struct stat st;
    ssize_t sent;

    /* Open the file for reading */
    filefd = open(filename, O_RDONLY);
    if (filefd == -1) {
        perror("open");
        return -1;
    }

    /* Find out how large the file is */
    if (fstat(filefd, &st) == -1) {
        perror("fstat");
        close(filefd);
        return -1;
    }

    /*
     * sendfile():
     *   out_fd  = sockfd  (destination: the network socket)
     *   in_fd   = filefd  (source: the file on disk)
     *   offset  = NULL    (start from current file position, i.e., the beginning)
     *   count   = st.st_size (transfer the whole file)
     *
     * Data goes: disk → kernel page cache → socket send buffer
     * It NEVER passes through user space (zero-copy from app's perspective).
     */
    sent = sendfile(sockfd, filefd, NULL, st.st_size);
    if (sent == -1) {
        perror("sendfile");
        close(filefd);
        return -1;
    }

    printf("Sent %zd bytes from '%s'\n", sent, filename);
    close(filefd);
    return 0;
}

Using the offset Parameter — Send Part of a File

The offset parameter is powerful. It lets you send a portion of a file without seeking, and it does not disturb the file descriptor’s own position — which is important if another part of your program is also reading from that file.

#include <sys/sendfile.h>
#include <stdio.h>

/*
 * Send 'count' bytes from 'filefd' starting at byte 'start_offset'.
 * The file descriptor's own position is NOT changed.
 */
int send_file_range(int sockfd, int filefd, off_t start_offset, size_t count)
{
    off_t offset = start_offset;  /* sendfile will update this */
    ssize_t sent;

    /*
     * By passing &offset (non-NULL):
     * - sendfile() reads from 'offset' bytes into the file
     * - After the call, 'offset' is updated to the next byte position
     * - The file descriptor's own seek position is left unchanged
     */
    sent = sendfile(sockfd, filefd, &offset, count);
    if (sent == -1) {
        perror("sendfile");
        return -1;
    }

    printf("Sent %zd bytes starting from offset %ld\n",
           sent, (long)start_offset);
    printf("Next offset would be: %ld\n", (long)offset);
    return 0;
}

/* Example: Serve byte ranges for HTTP Range requests */
void serve_range_request(int sockfd, int filefd,
                         off_t range_start, off_t range_end)
{
    size_t bytes_to_send = (size_t)(range_end - range_start + 1);
    send_file_range(sockfd, filefd, range_start, bytes_to_send);
}

Handling Large Files — Loop Until Done

sendfile() may transfer fewer bytes than requested — for example, if the socket send buffer fills up temporarily. For large files, always loop until all bytes are sent:

#include <sys/sendfile.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

int send_file_complete(int sockfd, const char *filename)
{
    int filefd;
    struct stat st;
    off_t offset = 0;
    ssize_t sent;
    size_t remaining;

    filefd = open(filename, O_RDONLY);
    if (filefd == -1) { perror("open"); return -1; }

    if (fstat(filefd, &st) == -1) {
        perror("fstat");
        close(filefd);
        return -1;
    }

    remaining = st.st_size;

    /*
     * Loop until all bytes are sent.
     * sendfile() updates 'offset' on each call, so we do not
     * need to track it separately.
     */
    while (remaining > 0) {
        sent = sendfile(sockfd, filefd, &offset, remaining);
        if (sent == -1) {
            perror("sendfile");
            close(filefd);
            return -1;
        }
        if (sent == 0)
            break;   /* unexpected EOF on source file */

        remaining -= sent;
        printf("Progress: %zu bytes remaining\n", remaining);
    }

    printf("File transfer complete: %lld bytes total\n",
           (long long)st.st_size);
    close(filefd);
    return 0;
}

Real-World Example — Minimal HTTP File Server

This is a simplified example of how a real web server might serve a static file. It combines HTTP header sending (with send()) and file body transfer (with sendfile()).

#include <sys/sendfile.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>

void serve_file(int client_sockfd, const char *filepath)
{
    int filefd;
    struct stat st;
    char http_header[512];
    int header_len;

    /* Open requested file */
    filefd = open(filepath, O_RDONLY);
    if (filefd == -1) {
        /* File not found — send 404 */
        const char *not_found =
            "HTTP/1.1 404 Not Found\r\n"
            "Content-Length: 0\r\n\r\n";
        send(client_sockfd, not_found, strlen(not_found), 0);
        return;
    }

    fstat(filefd, &st);

    /* Build HTTP response header */
    header_len = snprintf(http_header, sizeof(http_header),
        "HTTP/1.1 200 OK\r\n"
        "Content-Length: %lld\r\n"
        "Connection: close\r\n"
        "\r\n",
        (long long)st.st_size);

    /* Send header using regular send() */
    send(client_sockfd, http_header, header_len, 0);

    /*
     * Send file body using sendfile() — zero-copy.
     * No need to allocate a buffer or loop for read/write.
     * Data goes straight from kernel page cache to socket buffer.
     */
    off_t offset = 0;
    size_t remaining = st.st_size;

    while (remaining > 0) {
        ssize_t sent = sendfile(client_sockfd, filefd, &offset, remaining);
        if (sent <= 0) break;
        remaining -= sent;
    }

    close(filefd);
}

Limitations and Important Notes

read-write Loop vs sendfile() — Performance Comparison