sendfile系统调用及示例

#include <sys/sendfile.h> // 必需

ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

// 注意：这是一个简化的示例，缺少完整的 HTTP 解析、错误处理等。
// 编译时需要链接网络库: gcc -o sendfile_server sendfile_server.c

#include <sys/sendfile.h>  // sendfile
#include <sys/socket.h>    // socket, bind, listen, accept, send, recv
#include <sys/stat.h>      // fstat
#include <fcntl.h>         // open
#include <netinet/in.h>    // sockaddr_in
#include <arpa/inet.h>     // inet_addr
#include <unistd.h>        // close, fstat
#include <stdio.h>         // perror, printf
#include <stdlib.h>        // exit
#include <string.h>        // strstr, strlen

#define PORT 8080
#define BUFFER_SIZE 1024

void send_http_response(int client_sock, const char *status_line, const char *headers) {
    char response[BUFFER_SIZE];
    int len = snprintf(response, sizeof(response), "%s\r\n%s\r\n", status_line, headers);
    if (len > 0 && len < sizeof(response)) {
        send(client_sock, response, len, 0);
    }
}

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    int file_fd;
    struct stat file_stat;
    off_t offset;
    ssize_t bytes_sent;

    // 1. 创建套接字文件描述符
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 2. 配置服务器地址
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 3. 绑定套接字
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 4. 监听
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d\n", PORT);

    // 5. 接受客户端连接 (这里简化为处理一个连接)
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Client connected.\n");

    // 6. 简单读取客户端请求 (假设是 GET / HTTP/1.1)
    char buffer[BUFFER_SIZE] = {0};
    read(new_socket, buffer, BUFFER_SIZE - 1);
    printf("Received request:\n%s\n", buffer);

    // 7. 简单解析，检查是否请求根路径 "/"
    if (strstr(buffer, "GET / ") != NULL) {
        const char *filename = "index.html"; // 假设服务器根目录下有 index.html

        // 8. 打开要发送的文件
        file_fd = open(filename, O_RDONLY);
        if (file_fd == -1) {
            perror("open file");
            const char *not_found = "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n";
            send(new_socket, not_found, strlen(not_found), 0);
            close(new_socket);
            close(server_fd);
            exit(EXIT_FAILURE);
        }

        // 9. 获取文件状态 (主要是大小)
        if (fstat(file_fd, &file_stat) == -1) {
            perror("fstat");
            close(file_fd);
            close(new_socket);
            close(server_fd);
            exit(EXIT_FAILURE);
        }

        // 10. 发送 HTTP 响应头
        char headers[BUFFER_SIZE];
        snprintf(headers, sizeof(headers),
                 "HTTP/1.1 200 OK\r\n"
                 "Content-Type: text/html\r\n"
                 "Content-Length: %ld\r\n"
                 "\r\n",
                 (long)file_stat.st_size);
        send(new_socket, headers, strlen(headers), 0);
        printf("Sent HTTP headers.\n");

        // 11. 使用 sendfile 发送文件内容
        offset = 0;
        ssize_t remaining = file_stat.st_size;
        while (remaining > 0) {
            // sendfile 可能不会一次发送完所有数据
            bytes_sent = sendfile(new_socket, file_fd, &offset, remaining);
            if (bytes_sent == -1) {
                perror("sendfile");
                break;
            }
            remaining -= bytes_sent;
            printf("Sent %zd bytes, %zd bytes remaining.\n", bytes_sent, remaining);
        }

        if (remaining == 0) {
            printf("File sent successfully using sendfile.\n");
        } else {
            printf("Error or incomplete transfer.\n");
        }

        close(file_fd);
    } else {
        // 处理其他请求或发送 404
        const char *not_found = "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n";
        send(new_socket, not_found, strlen(not_found), 0);
    }

    // 12. 关闭连接和服务器套接字
    close(new_socket);
    close(server_fd);

    printf("Connection closed.\n");
    return 0;
}

#define _GNU_SOURCE // 启用 GNU 扩展以使用 sendfile 的新特性
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *source_filename = "source_file.txt";
    const char *dest_filename = "dest_file_copy.txt";
    int src_fd, dest_fd;
    struct stat stat_buf;
    ssize_t total_bytes = 0;
    ssize_t bytes_sent;
    off_t offset = 0;

    // 1. 创建并写入源文件
    src_fd = open(source_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (src_fd == -1) {
        perror("open source file for writing");
        exit(EXIT_FAILURE);
    }
    const char *data = "This is the content of the source file.\nIt has multiple lines.\n";
    if (write(src_fd, data, strlen(data)) == -1) {
        perror("write to source file");
        close(src_fd);
        exit(EXIT_FAILURE);
    }
    close(src_fd);

    printf("Created source file '%s'.\n", source_filename);

    // 2. 打开源文件 (只读)
    src_fd = open(source_filename, O_RDONLY);
    if (src_fd == -1) {
        perror("open source file for reading");
        exit(EXIT_FAILURE);
    }

    // 3. 获取源文件大小
    if (fstat(src_fd, &stat_buf) == -1) {
        perror("fstat source file");
        close(src_fd);
        exit(EXIT_FAILURE);
    }

    // 4. 创建/打开目标文件 (写入/创建/截断)
    dest_fd = open(dest_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (dest_fd == -1) {
        perror("open destination file");
        close(src_fd);
        exit(EXIT_FAILURE);
    }

    printf("Copying '%s' to '%s' using sendfile...\n", source_filename, dest_filename);

    // 5. 使用 sendfile 复制数据
    // 注意：在旧内核上，这可能会失败，因为 out_fd 不是套接字
    while (total_bytes < stat_buf.st_size) {
        // 计算本次要发送的字节数 (防止溢出)
        size_t count = stat_buf.st_size - total_bytes;
        if (count > 0x7ffff000) { // sendfile 一次传输上限 (约 2GB)
            count = 0x7ffff000;
        }

        bytes_sent = sendfile(dest_fd, src_fd, &offset, count);
        if (bytes_sent == -1) {
            perror("sendfile");
            // 可能是内核不支持普通文件作为 out_fd
            if (errno == EINVAL) {
                printf("Error: sendfile likely doesn't support copying between regular files on this system/kernel.\n");
                printf("Consider using splice or standard read/write loop instead.\n");
            }
            close(src_fd);
            close(dest_fd);
            exit(EXIT_FAILURE);
        }
        total_bytes += bytes_sent;
        printf("Copied %zd bytes in this call, total: %zd/%ld\n",
               bytes_sent, total_bytes, (long)stat_buf.st_size);
    }

    printf("File copy completed successfully. %zd bytes copied.\n", total_bytes);

    // 6. 清理
    close(src_fd);
    close(dest_fd);

    return 0;
}