The Problem – Why read() + write() is Wasteful

Imagine you are writing a simple file server. A client requests a file. You open the file, read its contents into a buffer, and then write that buffer to the socket. That is the classic approach and it looks like this in code:

/* Traditional approach – two system calls, two data copies */
int fd = open("page.html", O_RDONLY);
char buf[4096];
ssize_t n;

while ((n = read(fd, buf, sizeof(buf))) > 0) {
    write(sockfd, buf, n);   /* send to client */
}

This works, but it is not efficient. Here is what actually happens inside the kernel when you call read() followed by write():

Steps 2 and 3 involve CPU-driven copies through user space. Your application never actually looks at the data – it just moves it. These copies burn CPU cycles and pollute CPU caches, especially for large files. This is the inefficiency that sendfile() was designed to fix.

The Solution – Zero-Copy with sendfile()

With sendfile(), the kernel transfers data from the file’s buffer cache directly to the socket’s send buffer without ever passing through user space. The application does not need a buffer at all.

The two wasteful CPU copies in the middle are gone. This is called a zero-copy transfer because no data passes through user space.

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 on success, -1 on error */

Let us go through each argument one by one:

Understanding the offset argument

The offset argument gives you two modes of operation:

Code Examples

Example 1 – Basic sendfile() usage

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

/*
 * send_file_to_socket - sends a file to a connected socket using zero-copy
 * file_path : path of file to send
 * sockfd    : connected TCP socket
 * Returns   : 0 on success, -1 on error
 */
int send_file_to_socket(const char *file_path, int sockfd)
{
    int       file_fd;
    struct stat file_stat;
    off_t     offset;
    ssize_t   sent;
    size_t    remaining;

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

    /* Get the file size */
    if (fstat(file_fd, &file_stat) == -1) {
        perror("fstat");
        close(file_fd);
        return -1;
    }

    offset    = 0;                   /* start from beginning of file */
    remaining = file_stat.st_size;   /* total bytes to send */

    /*
     * Loop because sendfile() may transfer fewer bytes than requested.
     * This can happen when the socket send buffer is temporarily full.
     */
    while (remaining > 0) {
        sent = sendfile(sockfd, file_fd, &offset, remaining);
        if (sent == -1) {
            perror("sendfile");
            close(file_fd);
            return -1;
        }
        remaining -= sent;
        /* offset is automatically updated by sendfile() */
    }

    close(file_fd);
    return 0;  /* all bytes sent */
}

Example 2 – Sending a file from a specific offset

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

/*
 * Demonstrate offset-based sendfile().
 * Useful for sending a specific portion of a large file,
 * e.g. resumable downloads (HTTP Range requests).
 */
void send_range(int sockfd, int file_fd, off_t start, size_t length)
{
    off_t   offset = start;   /* sendfile() will update this */
    ssize_t sent;
    size_t  remaining = length;

    while (remaining > 0) {
        sent = sendfile(sockfd, file_fd, &offset, remaining);
        if (sent <= 0) {
            perror("sendfile range");
            return;
        }
        remaining -= sent;
        /*
         * After the call:
         *   offset == start + bytes_transferred_so_far
         * The file's own seek position is NOT changed.
         */
    }

    printf("Sent %zu bytes starting from offset %ld\n", length, (long)start);
}

Example 3 – A minimal file server using sendfile()

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/sendfile.h>
#include <netinet/in.h>

#define PORT 8080

int main(void)
{
    int                server_fd, client_fd, file_fd;
    struct sockaddr_in addr;
    struct stat        st;
    off_t              offset;
    char               filepath[] = "data.bin";

    /* Create TCP socket */
    server_fd = socket(AF_INET, SOCK_STREAM, 0);

    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port        = htons(PORT);

    bind(server_fd, (struct sockaddr *)&addr, sizeof(addr));
    listen(server_fd, 5);

    printf("File server listening on port %d...\n", PORT);

    while (1) {
        client_fd = accept(server_fd, NULL, NULL);
        if (client_fd == -1) { perror("accept"); continue; }

        file_fd = open(filepath, O_RDONLY);
        if (file_fd == -1) { perror("open"); close(client_fd); continue; }

        fstat(file_fd, &st);
        offset = 0;

        /* Send entire file in one call (or loop if partial) */
        ssize_t n = sendfile(client_fd, file_fd, &offset, st.st_size);
        if (n == -1) perror("sendfile");
        else         printf("Sent %zd bytes to client\n", n);

        close(file_fd);
        close(client_fd);
    }

    close(server_fd);
    return 0;
}

Important Restrictions

splice(), vmsplice(), and tee()

Starting with Linux kernel 2.6.17, three new system calls were added that are a superset of sendfile():

Interview Questions & Answers