readv系统调用及示例

#include <sys/uio.h> // 必需，包含 struct iovec 的定义

// 分散读取
ssize_t readv(int fd, const struct iovec *iov, int iovcnt);

// 集中写入
ssize_t writev(int fd, const struct iovec *iov, int iovcnt);

#include <sys/uio.h>  // writev, struct iovec
#include <unistd.h>   // STDOUT_FILENO
#include <stdio.h>    // perror
#include <stdlib.h>   // exit
#include <string.h>   // strlen

int main() {
    // 定义要写入的数据
    char part1[] = "Hello, ";
    char part2[] = "this is ";
    char part3[] = "a message ";
    char part4[] = "written using writev!\n";

    // 定义 iovec 结构体数组，描述各个缓冲区
    struct iovec iov[4];
    ssize_t bytes_written;

    // 填充 iovec 数组
    iov[0].iov_base = part1;
    iov[0].iov_len  = strlen(part1);

    iov[1].iov_base = part2;
    iov[1].iov_len  = strlen(part2);

    iov[2].iov_base = part3;
    iov[2].iov_len  = strlen(part3);

    iov[3].iov_base = part4;
    iov[3].iov_len  = strlen(part4);

    // 调用 writev 将所有部分集中写入到标准输出 (STDOUT_FILENO)
    bytes_written = writev(STDOUT_FILENO, iov, 4);

    if (bytes_written == -1) {
        perror("writev failed");
        exit(EXIT_FAILURE);
    }

    printf("writev successfully wrote %zd bytes.\n", bytes_written);

    return 0;
}

#include <sys/uio.h>  // readv, struct iovec
#include <fcntl.h>    // open
#include <unistd.h>   // readv, write, close
#include <stdio.h>    // perror, printf
#include <stdlib.h>   // exit
#include <string.h>   // memset

int main() {
    int fd;
    const char *filename = "source_data.txt";
    const char *source_content = "This is a sample text file with enough content to demonstrate readv.\n"
                                 "It has multiple lines and words to fill the buffers.\n"
                                 "End of sample data.\n";
    struct iovec iov[3];
    char buf1[20], buf2[30], buf3[50]; // 定义三个大小不同的缓冲区
    ssize_t bytes_read;
    ssize_t total_len;

    // 1. 创建并写入源文件
    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open file for writing");
        exit(EXIT_FAILURE);
    }
    total_len = write(fd, source_content, strlen(source_content));
    if (total_len == -1) {
        perror("write source content");
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("Created source file '%s' with %zd bytes.\n", filename, total_len);
    close(fd);

    // 2. 重新打开文件以供读取
    fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("open file for reading");
        exit(EXIT_FAILURE);
    }

    // 3. 初始化缓冲区 (可选，用于查看未填充的部分)
    memset(buf1, '.', sizeof(buf1) - 1);
    buf1[sizeof(buf1) - 1] = '\0';
    memset(buf2, '.', sizeof(buf2) - 1);
    buf2[sizeof(buf2) - 1] = '\0';
    memset(buf3, '.', sizeof(buf3) - 1);
    buf3[sizeof(buf3) - 1] = '\0';

    // 4. 设置 iovec 结构体数组
    iov[0].iov_base = buf1;
    iov[0].iov_len  = sizeof(buf1) - 1; // 留一个字节给字符串结束符 \0

    iov[1].iov_base = buf2;
    iov[1].iov_len  = sizeof(buf2) - 1;

    iov[2].iov_base = buf3;
    iov[2].iov_len  = sizeof(buf3) - 1;


    // 5. 调用 readv 进行分散读取
    bytes_read = readv(fd, iov, 3);

    if (bytes_read == -1) {
        perror("readv failed");
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("\nreadv successfully read %zd bytes.\n", bytes_read);

    // 6. 确保字符串以 \0 结尾 (因为 readv 不会自动添加)
    // 我们预留了空间，所以直接添加
    buf1[iov[0].iov_len] = '\0';
    buf2[iov[1].iov_len] = '\0';
    buf3[iov[2].iov_len] = '\0';

    // 7. 打印读取到的内容
    printf("\n--- Content of buffers after readv ---\n");
    printf("Buffer 1 (%zu bytes max): '%s'\n", sizeof(buf1) - 1, buf1);
    printf("Buffer 2 (%zu bytes max): '%s'\n", sizeof(buf2) - 1, buf2);
    printf("Buffer 3 (%zu bytes max): '%s'\n", sizeof(buf3) - 1, buf3);

    // 8. 关闭文件
    if (close(fd) == -1) {
        perror("close");
        exit(EXIT_FAILURE);
    }

    return 0;
}

#include <sys/uio.h>  // writev, struct iovec
#include <sys/socket.h> // send, sendmsg (概念性)
#include <stdio.h>    // printf
#include <string.h>   // strlen
// #include <unistd.h> // 如果使用 writev 直接写 socket fd

// 假设这些数据是动态生成的
const char *http_header = "HTTP/1.1 200 OK\r\n"
                          "Content-Type: text/plain\r\n"
                          "Connection: close\r\n"
                          "\r\n"; // Header 和 Body 之间需要空行

const char *http_body = "Hello, World! This is the response body.\n";

// 模拟发送 HTTP 响应的函数 (概念性)
int send_http_response(int client_socket_fd /* , const char *header, const char *body */) {
    struct iovec iov[2];
    ssize_t total_bytes, bytes_sent;

    // 设置 iovec 数组
    iov[0].iov_base = (void*)http_header; // 强制类型转换，因为 iov_base 是 void*
    iov[0].iov_len  = strlen(http_header);

    iov[1].iov_base = (void*)http_body;
    iov[1].iov_len  = strlen(http_body);

    // 使用 writev 发送 (假设 socket fd 可以像文件一样 writev)
    // 在实际网络编程中，更常用 sendmsg 或者循环 send/write
    // 这里用 writev 演示 gather output 的概念
    bytes_sent = writev(client_socket_fd, iov, 2);

    if (bytes_sent == -1) {
        perror("writev failed in send_http_response");
        return -1; // Indicate failure
    }

    total_bytes = iov[0].iov_len + iov[1].iov_len;
    printf("Sent HTTP response using writev: %zd of %zd bytes.\n", bytes_sent, total_bytes);

    if (bytes_sent != total_bytes) {
        fprintf(stderr, "Warning: Incomplete writev. Sent %zd, Expected %zd.\n", bytes_sent, total_bytes);
        // 在实际应用中，可能需要处理部分发送的情况
        return -1;
    }

    return 0; // Success
}

// 主函数 (概念性)
int main() {
    int simulated_client_socket_fd = 1; // 假设 1 是一个有效的 socket fd (这里用 stdout 模拟)

    printf("--- Simulating sending HTTP response ---\n");
    // 调用函数发送响应
    if (send_http_response(simulated_client_socket_fd) == -1) {
        fprintf(stderr, "Failed to send HTTP response.\n");
        return 1;
    }

    printf("--- HTTP response sent ---\n");
    return 0;
}