// 需要定义宏来启用 AIO 和 io_pgetevents
#define _GNU_SOURCE
#include <linux/aio_abi.h> // 包含 AIO 相关结构体和常量 (io_context_t, io_event, iocb)
#include <sys/syscall.h>   // 包含 syscall 函数和系统调用号
#include <unistd.h>        // 包含 syscall 函数
#include <signal.h>        // 包含 sigset_t 等 (io_pgetevents)

// io_getevents 系统调用
long syscall(SYS_io_getevents, io_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout);

// io_pgetevents 系统调用
long syscall(SYS_io_pgetevents, io_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout, const sigset_t *sigmask);

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include <linux/aio_abi.h>
#include <sys/syscall.h>
#include <sys/time.h> // 包含 gettimeofday

// 辅助函数：调用 io_setup 系统调用
static inline int io_setup(unsigned nr_events, io_context_t *ctxp) {
    return syscall(__NR_io_setup, nr_events, ctxp);
}

// 辅助函数：调用 io_destroy 系统调用
static inline int io_destroy(io_context_t ctx) {
    return syscall(__NR_io_destroy, ctx);
}

// 辅助函数：调用 io_submit 系统调用
static inline int io_submit(io_context_t ctx, long nr, struct iocb **iocbpp) {
    return syscall(__NR_io_submit, ctx, nr, iocbpp);
}

// 辅助函数：调用 io_getevents 系统调用
static inline int io_getevents(io_context_t ctx, long min_nr, long nr, struct io_event *events, struct timespec *timeout) {
    return syscall(__NR_io_getevents, ctx, min_nr, nr, events, timeout);
}

// 辅助函数：初始化一个异步读取的 iocb 结构
void prep_read(struct iocb *iocb, int fd, void *buf, size_t count, __u64 offset, __u64 data) {
    // 清零结构体
    memset(iocb, 0, sizeof(*iocb));
    // 设置操作类型为pread (异步pread)
    iocb->aio_lio_opcode = IOCB_CMD_PREAD;
    // 设置文件描述符
    iocb->aio_fildes = fd;
    // 设置缓冲区
    iocb->aio_buf = (__u64)(unsigned long)buf;
    // 设置读取字节数
    iocb->aio_nbytes = count;
    // 设置文件偏移量
    iocb->aio_offset = offset;
    // 设置用户数据 (可选，用于匹配事件)
    iocb->aio_data = data;
}

int main() {
    const char *filename = "aio_test_file.txt";
    const int num_reads = 3;
    const size_t chunk_size = 1024;
    int fd;
    io_context_t ctx = 0; // 必须初始化为 0
    struct iocb iocbs&#91;num_reads];
    struct iocb *iocb_ptrs&#91;num_reads];
    char buffers&#91;num_reads]&#91;chunk_size];
    struct io_event events&#91;num_reads];
    struct timespec timeout;
    int ret, i;
    struct timeval start, end;
    double elapsed_time;

    printf("--- Demonstrating io_getevents (Linux AIO) ---\n");

    // 1. 创建一个测试文件
    fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, 0644);
    if (fd == -1) {
        perror("open (create)");
        exit(EXIT_FAILURE);
    }
    char test_data&#91;1024];
    memset(test_data, 'A', sizeof(test_data));
    for (int j = 0; j < 10; ++j) { // 写入 10KB 数据
        if (write(fd, test_data, sizeof(test_data)) != sizeof(test_data)) {
            perror("write");
            close(fd);
            exit(EXIT_FAILURE);
        }
    }
    close(fd);
    printf("Created test file '%s' with 10KB of data.\n", filename);

    // 2. 以只读方式打开文件
    fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("open (read)");
        exit(EXIT_FAILURE);
    }

    // 3. 初始化异步 I/O 上下文
    // 我们需要能处理至少 num_reads 个并发请求
    ret = io_setup(num_reads, &ctx);
    if (ret < 0) {
        perror("io_setup");
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("Initialized AIO context.\n");

    // 4. 准备 I/O 请求 (iocb)
    for (i = 0; i < num_reads; ++i) {
        // 从文件不同偏移读取
        prep_read(&iocbs&#91;i], fd, buffers&#91;i], chunk_size, i * chunk_size, i + 1);
        iocb_ptrs&#91;i] = &iocbs&#91;i];
        printf("Prepared read request %d: offset=%zu, size=%zu\n", i+1, i * chunk_size, chunk_size);
    }

    // 5. 提交 I/O 请求
    gettimeofday(&start, NULL);
    printf("Submitting %d asynchronous read requests...\n", num_reads);
    ret = io_submit(ctx, num_reads, iocb_ptrs);
    if (ret != num_reads) {
        fprintf(stderr, "io_submit failed: submitted %d, expected %d\n", ret, num_reads);
        if (ret < 0) perror("io_submit");
        io_destroy(ctx);
        close(fd);
        exit(EXIT_FAILURE);
    }
    gettimeofday(&end, NULL);
    elapsed_time = ((end.tv_sec - start.tv_sec) * 1000.0) + ((end.tv_usec - start.tv_usec) / 1000.0);
    printf("Submitted all requests in %.2f ms.\n", elapsed_time);

    // 6. 等待并获取完成的事件 (使用 io_getevents)
    printf("Waiting for completion events using io_getevents...\n");
    gettimeofday(&start, NULL);

    // 设置超时为 5 秒
    timeout.tv_sec = 5;
    timeout.tv_nsec = 0;

    // 等待所有 num_reads 个事件完成
    ret = io_getevents(ctx, num_reads, num_reads, events, &timeout);
    gettimeofday(&end, NULL);
    elapsed_time = ((end.tv_sec - start.tv_sec) * 1000.0) + ((end.tv_usec - start.tv_usec) / 1000.0);

    if (ret < 0) {
        perror("io_getevents");
        io_destroy(ctx);
        close(fd);
        exit(EXIT_FAILURE);
    }

    if (ret < num_reads) {
        printf("Warning: Only got %d events out of %d expected within timeout.\n", ret, num_reads);
    } else {
        printf("Received all %d completion events in %.2f ms.\n", ret, elapsed_time);
    }

    // 7. 处理完成的事件
    printf("\n--- Processing Completion Events ---\n");
    for (i = 0; i < ret; ++i) {
        struct io_event *ev = &events&#91;i];
        printf("Event %d:\n", i+1);
        printf("  Request ID (user data): %llu\n", (unsigned long long)ev->data);
        // printf("  Request pointer: %llu\n", (unsigned long long)ev->obj); // 内核地址，通常不直接使用
        if (ev->res >= 0) {
            printf("  Result: Success, %lld bytes read.\n", (long long)ev->res);
            // 可以检查 buffers&#91;ev->data - 1] 中的数据
            // printf("  First byte: %c\n", buffers&#91;ev->data - 1]&#91;0]);
        } else {
            printf("  Result: Error, code %lld (%s)\n", (long long)ev->res, strerror(-ev->res));
        }
        printf("\n");
    }

    // 8. 清理资源
    printf("--- Cleaning up ---\n");
    io_destroy(ctx);
    printf("Destroyed AIO context.\n");
    close(fd);
    printf("Closed file descriptor.\n");
    unlink(filename); // 删除测试文件
    printf("Deleted test file '%s'.\n", filename);

    printf("\n--- Summary ---\n");
    printf("1. io_getevents retrieves completed asynchronous I/O operations.\n");
    printf("2. It works with an io_context_t created by io_setup.\n");
    printf("3. It waits for events based on min_nr, nr, and timeout.\n");
    printf("4. io_pgetevents is similar but allows setting a signal mask during wait.\n");
    printf("5. Linux AIO has some limitations; io_uring is the modern, preferred approach.\n");

    return 0;
}

# 假设代码保存在 aio_getevents_example.c 中
gcc -o aio_getevents_example aio_getevents_example.c

# 运行程序
./aio_getevents_example

--- Demonstrating io_getevents (Linux AIO) ---
Created test file 'aio_test_file.txt' with 10KB of data.
Initialized AIO context.
Prepared read request 1: offset=0, size=1024
Prepared read request 2: offset=1024, size=1024
Prepared read request 3: offset=2048, size=1024
Submitting 3 asynchronous read requests...
Submitted all requests in 0.05 ms.
Waiting for completion events using io_getevents...
Received all 3 completion events in 2.15 ms.

--- Processing Completion Events ---
Event 1:
  Request ID (user data): 1
  Result: Success, 1024 bytes read.

Event 2:
  Request ID (user data): 2
  Result: Success, 1024 bytes read.

Event 3:
  Request ID (user data): 3
  Result: Success, 1024 bytes read.

--- Cleaning up ---
Destroyed AIO context.
Closed file descriptor.
Deleted test file 'aio_test_file.txt'.

--- Summary ---
1. io_getevents retrieves completed asynchronous I/O operations.
2. It works with an io_context_t created by io_setup.
3. It waits for events based on min_nr, nr, and timeout.
4. io_pgetevents is similar but allows setting a signal mask during wait.
5. Linux AIO has some limitations; io_uring is the modern, preferred approach.

// 假设已定义 syscall 号 __NR_io_pgetevents
long io_pgetevents(io_context_t ctx, long min_nr, long nr, struct io_event *events, struct timespec *timeout, const sigset_t *sigmask);

// 使用示例 (概念性)
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, SIGUSR1);

struct timespec timeout = {5, 0}; // 5秒超时
int ret = syscall(__NR_io_pgetevents, ctx, 1, 1, events, &timeout, &mask);
// 在等待期间，只有 SIGUSR1 能中断此调用

#include <linux/aio_abi.h> // 包含 io_event 结构体等 AIO 相关定义
#include <signal.h>        // sigset_t
#include <sys/syscall.h>   // syscall
#include <unistd.h>

// 注意：glibc 通常不直接包装 io_pgetevents，需要使用 syscall
// 系统调用号在不同架构上不同，例如 x86_64 上是 333 (SYS_io_pgetevents)

// 通过 syscall 调用的原型 (概念上)
long io_pgetevents(aio_context_t ctx_id,
                   long min_nr,
                   long nr,
                   struct io_event *events,
                   struct timespec *timeout,
                   const struct __aio_sigset *usig);

// aio_pgetevents_example.c
// 编译: gcc -o aio_pgetevents_example aio_pgetevents_example.c
#define _GNU_SOURCE // For syscall, SIGUSR1, etc.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/syscall.h>
#include <linux/aio_abi.h>
#include <signal.h>
#include <sys/stat.h>
#include <assert.h>
#include <pthread.h> // For pthread_kill in signal sender

// 定义系统调用号 (x86_64)
#ifndef SYS_io_pgetevents
#define SYS_io_pgetevents 333
#endif
#ifndef SYS_io_setup
#define SYS_io_setup 206
#endif
#ifndef SYS_io_destroy
#define SYS_io_destroy 207
#endif
#ifndef SYS_io_submit
#define SYS_io_submit 209
#endif
#ifndef SYS_io_getevents
#define SYS_io_getevents 208
#endif

// 包装 io_pgetevents 系统调用
static inline int io_pgetevents(aio_context_t ctx, long min_nr, long nr,
                                struct io_event *events,
                                struct timespec *timeout,
                                struct __aio_sigset *usig) {
    return syscall(SYS_io_pgetevents, ctx, min_nr, nr, events, timeout, usig);
}

// 包装 io_setup
static inline int io_setup(unsigned nr_events, aio_context_t *ctx_idp) {
    return syscall(SYS_io_setup, nr_events, ctx_idp);
}

// 包装 io_destroy
static inline int io_destroy(aio_context_t ctx) {
    return syscall(SYS_io_destroy, ctx);
}

// 包装 io_submit
static inline int io_submit(aio_context_t ctx, long nr, struct iocb **iocbpp) {
    return syscall(SYS_io_submit, ctx, nr, iocbpp);
}

#define NUM_REQUESTS 2
#define BUFFER_SIZE 1024

// 信号处理函数
void signal_handler(int sig) {
    printf("Signal %d received in main thread!\n", sig);
}

// 发送信号的线程函数
void* signal_sender_thread(void *arg) {
    pid_t main_tid = *(pid_t*)arg;
    sleep(2); // 等待 main 线程进入 io_pgetevents
    printf("Signal sender: Sending SIGUSR1 to main thread (TID %d)...\n", main_tid);
    // 注意：pthread_kill 发送给线程，kill 发送给进程
    // 这里假设 main_tid 是线程 ID (实际获取线程 ID 需要 gettid() 或其他方法)
    // 为简化，我们用 kill 发送给整个进程
    // pthread_kill 需要更复杂的设置，这里用 kill 演示
    if (kill(getpid(), SIGUSR1) != 0) {
        perror("kill SIGUSR1");
    }
    return NULL;
}

int main() {
    const char *filename = "test_aio_file.txt";
    int fd;
    aio_context_t ctx = 0;
    struct iocb iocbs&#91;NUM_REQUESTS];
    struct iocb *iocb_ptrs&#91;NUM_REQUESTS];
    struct io_event events&#91;NUM_REQUESTS];
    char buffers&#91;NUM_REQUESTS]&#91;BUFFER_SIZE];
    struct sigaction sa;
    sigset_t block_sigusr1, oldset;
    struct __aio_sigset aio_sigset;
    pthread_t sig_thread;
    pid_t main_tid = getpid(); // Simplification for example

    // 1. 创建测试文件
    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open test file for writing");
        exit(EXIT_FAILURE);
    }
    const char *test_data = "This is test data for asynchronous I/O operation number one.\n"
                            "This is test data for asynchronous I/O operation number two.\n";
    if (write(fd, test_data, strlen(test_data)) != (ssize_t)strlen(test_data)) {
        perror("write test data");
        close(fd);
        exit(EXIT_FAILURE);
    }
    close(fd);
    printf("Created test file '%s'.\n", filename);

    // 2. 设置信号处理
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0; // No SA_RESTART for demonstration
    if (sigaction(SIGUSR1, &sa, NULL) == -1) {
        perror("sigaction SIGUSR1");
        exit(EXIT_FAILURE);
    }
    printf("SIGUSR1 handler installed.\n");

    // 3. 打开文件进行异步读取
    fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("open test file for reading");
        exit(EXIT_FAILURE);
    }

    // 4. 初始化 AIO 上下文
    if (io_setup(NUM_REQUESTS, &ctx) < 0) {
        perror("io_setup");
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("AIO context created.\n");

    // 5. 准备 AIO 读取请求
    for (int i = 0; i < NUM_REQUESTS; i++) {
        // 初始化 iocb 结构
        memset(&iocbs&#91;i], 0, sizeof(struct iocb));
        iocbs&#91;i].aio_fildes = fd;
        iocbs&#91;i].aio_lio_opcode = IOCB_CMD_PREAD; // 异步预读
        iocbs&#91;i].aio_reqprio = 0;
        iocbs&#91;i].aio_buf = (uint64_t)(buffers&#91;i]); // 读入缓冲区
        iocbs&#91;i].aio_nbytes = BUFFER_SIZE / 2; // 读取一半缓冲区大小
        iocbs&#91;i].aio_offset = i * (BUFFER_SIZE / 2); // 从不同偏移量开始读
        iocbs&#91;i].aio_data = i + 1; // 用户数据，用于标识请求
        iocb_ptrs&#91;i] = &iocbs&#91;i];
    }

    // 6. 提交 AIO 请求
    printf("Submitting %d AIO read requests...\n", NUM_REQUESTS);
    int ret = io_submit(ctx, NUM_REQUESTS, iocb_ptrs);
    if (ret < 0) {
        perror("io_submit");
        io_destroy(ctx);
        close(fd);
        exit(EXIT_FAILURE);
    } else if (ret != NUM_REQUESTS) {
        fprintf(stderr, "Submitted %d requests, expected %d\n", ret, NUM_REQUESTS);
    } else {
        printf("Successfully submitted %d AIO requests.\n", ret);
    }

    // 7. 设置信号屏蔽 (用于 io_pgetevents)
    sigemptyset(&block_sigusr1);
    sigaddset(&block_sigusr1, SIGUSR1);
    aio_sigset.sigmask = &block_sigusr1;
    aio_sigset.sigsetsize = sizeof(block_sigusr1);

    // 8. 启动信号发送线程
    if (pthread_create(&sig_thread, NULL, signal_sender_thread, &main_tid) != 0) {
        perror("pthread_create signal sender");
        io_destroy(ctx);
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("Main thread: Waiting for AIO events with SIGUSR1 blocked atomically...\n");

    // 9. 关键：使用 io_pgetevents 等待，原子性地屏蔽 SIGUSR1
    // 这意味着在内核等待期间，SIGUSR1 会被阻塞。
    // 如果在此期间有 SIGUSR1 到达，它会被挂起，直到 io_pgetevents 返回。
    struct timespec timeout;
    timeout.tv_sec = 10; // 10 秒超时
    timeout.tv_nsec = 0;

    ret = io_pgetevents(ctx, 1, NUM_REQUESTS, events, &timeout, &aio_sigset);

    if (ret < 0) {
        if (errno == EINTR) {
            printf("io_pgetevents was interrupted by a signal (EINTR).\n");
        } else {
            perror("io_pgetevents");
        }
    } else {
        printf("io_pgetevents returned %d events:\n", ret);
        for (int i = 0; i < ret; i++) {
            printf("  Event %d: data=%llu, res=%lld\n",
                   i, (unsigned long long)events&#91;i].data, (long long)events&#91;i].res);
            if (events&#91;i].res > 0) {
                buffers&#91;events&#91;i].data - 1]&#91;events&#91;i].res] = '\0'; // Null-terminate
                printf("    Data: %s", buffers&#91;events&#91;i].data - 1]);
            }
        }
    }

    printf("Main thread: io_pgetevents finished.\n");

    // 10. 等待信号发送线程结束
    pthread_join(sig_thread, NULL);

    // 11. 清理资源
    io_destroy(ctx);
    close(fd);
    unlink(filename); // 删除测试文件

    printf("Example finished.\n");
    return 0;
}

// 需要定义宏来启用 AIO
#define _GNU_SOURCE
#include <linux/aio_abi.h> // 包含 AIO 相关结构体和常量 (io_context_t, iocb)
#include <sys/syscall.h>   // 包含 syscall 函数和系统调用号
#include <unistd.h>        // 包含 syscall 函数

// io_setup 系统调用
long syscall(SYS_io_setup, unsigned nr_events, io_context_t *ctxp);

// io_submit 系统调用
long syscall(SYS_io_submit, io_context_t ctx_id, long nr, struct iocb **iocbpp);

// 这是 linux/aio_abi.h 中定义的简化版结构
struct iocb {
    __u64 aio_data;          // 用户定义的数据，通常用于匹配请求和完成事件
    __u32 aio_key, aio_reserved1;

    __u16 aio_lio_opcode;    // 操作类型：IOCB_CMD_PREAD, IOCB_CMD_PWRITE 等
    __s16 aio_reqprio;       // 请求优先级 (通常保留为 0)
    __u32 aio_fildes;        // 文件描述符

    __u64 aio_buf;           // 缓冲区地址 (用户空间指针)
    __u64 aio_nbytes;        // 传输字节数
    __s64 aio_offset;        // 文件偏移量
    // ... 还有其他字段，用于更高级的功能
};

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include <linux/aio_abi.h>
#include <sys/syscall.h>

// 辅助函数：调用 io_setup 系统调用
static inline int io_setup(unsigned nr_events, io_context_t *ctxp) {
    return syscall(__NR_io_setup, nr_events, ctxp);
}

// 辅助函数：调用 io_destroy 系统调用
static inline int io_destroy(io_context_t ctx) {
    return syscall(__NR_io_destroy, ctx);
}

// 辅助函数：调用 io_submit 系统调用
static inline int io_submit(io_context_t ctx, long nr, struct iocb **iocbpp) {
    return syscall(__NR_io_submit, ctx, nr, iocbpp);
}

// 辅助函数：调用 io_getevents 系统调用
static inline int io_getevents(io_context_t ctx, long min_nr, long nr, struct io_event *events, struct timespec *timeout) {
    return syscall(__NR_io_getevents, ctx, min_nr, nr, events, timeout);
}

// 辅助函数：初始化一个异步读取的 iocb 结构
void prep_pread(struct iocb *iocb, int fd, void *buf, size_t count, __u64 offset) {
    // 清零结构体
    memset(iocb, 0, sizeof(*iocb));
    // 设置操作类型为pread (异步pread)
    iocb->aio_lio_opcode = IOCB_CMD_PREAD;
    // 设置文件描述符
    iocb->aio_fildes = fd;
    // 设置缓冲区
    iocb->aio_buf = (__u64)(unsigned long)buf;
    // 设置读取字节数
    iocb->aio_nbytes = count;
    // 设置文件偏移量
    iocb->aio_offset = offset;
    // 设置用户数据 (可选，用于匹配事件)
    iocb->aio_data = (__u64)(unsigned long)buf; // 这里简单地用 buf 地址作为标识
}

// 辅助函数：初始化一个异步写入的 iocb 结构
void prep_pwrite(struct iocb *iocb, int fd, const void *buf, size_t count, __u64 offset) {
    memset(iocb, 0, sizeof(*iocb));
    iocb->aio_lio_opcode = IOCB_CMD_PWRITE;
    iocb->aio_fildes = fd;
    iocb->aio_buf = (__u64)(unsigned long)buf;
    iocb->aio_nbytes = count;
    iocb->aio_offset = offset;
    iocb->aio_data = (__u64)(unsigned long)buf; // 用 buf 地址作为标识
}

int main() {
    const char *filename = "aio_test_file.txt";
    const int num_ops = 4; // 2次写入 + 2次读取
    const size_t chunk_size = 1024;
    int fd;
    io_context_t ctx = 0; // 必须初始化为 0
    struct iocb iocbs&#91;num_ops];
    struct iocb *iocb_ptrs&#91;num_ops];
    char write_buffers&#91;2]&#91;chunk_size];
    char read_buffers&#91;2]&#91;chunk_size];
    struct io_event events&#91;num_ops];
    int ret, i;

    printf("--- Demonstrating io_setup and io_submit (Linux AIO) ---\n");

    // 1. 初始化要写入的数据
    memset(write_buffers&#91;0], 'A', chunk_size);
    memset(write_buffers&#91;1], 'B', chunk_size);

    // 2. 创建并打开文件 (O_DIRECT 对 AIO 更友好，但为简单起见使用普通模式)
    fd = open(filename, O_CREAT | O_TRUNC | O_RDWR, 0644);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    printf("Opened/created file '%s'\n", filename);

    // 3. 初始化异步 I/O 上下文
    // 我们需要能处理至少 num_ops 个并发请求
    ret = io_setup(num_ops, &ctx);
    if (ret < 0) {
        perror("io_setup");
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("Initialized AIO context (ctx_id=%llu).\n", (unsigned long long)ctx);

    // 4. 准备写入请求
    prep_pwrite(&iocbs&#91;0], fd, write_buffers&#91;0], chunk_size, 0);
    prep_pwrite(&iocbs&#91;1], fd, write_buffers&#91;1], chunk_size, chunk_size);
    iocb_ptrs&#91;0] = &iocbs&#91;0];
    iocb_ptrs&#91;1] = &iocbs&#91;1];
    printf("Prepared 2 write requests.\n");

    // 5. 提交写入请求
    printf("Submitting write requests...\n");
    ret = io_submit(ctx, 2, iocb_ptrs);
    if (ret != 2) {
        fprintf(stderr, "io_submit (writes) failed: submitted %d, expected %d\n", ret, 2);
        if (ret < 0) perror("io_submit");
        io_destroy(ctx);
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("Submitted 2 write requests successfully.\n");

    // 6. 等待写入完成 (简单起见，等待所有已提交的)
    printf("Waiting for write completions...\n");
    struct timespec timeout = {5, 0}; // 5秒超时
    ret = io_getevents(ctx, 2, 2, events, &timeout);
    if (ret < 0) {
        perror("io_getevents (writes)");
        io_destroy(ctx);
        close(fd);
        exit(EXIT_FAILURE);
    }
    if (ret < 2) {
        printf("Warning: Only got %d write events, expected 2.\n", ret);
    } else {
        printf("Received %d write completion events.\n", ret);
        for (i = 0; i < ret; ++i) {
            if (events&#91;i].res < 0) {
                fprintf(stderr, "Write error: %s\n", strerror(-events&#91;i].res));
            } else {
                printf("Write %d completed: %lld bytes written.\n", i+1, (long long)events&#91;i].res);
            }
        }
    }

    // 7. 准备读取请求
    prep_pread(&iocbs&#91;2], fd, read_buffers&#91;0], chunk_size, 0);
    prep_pread(&iocbs&#91;3], fd, read_buffers&#91;1], chunk_size, chunk_size);
    iocb_ptrs&#91;0] = &iocbs&#91;2]; // 重用指针数组
    iocb_ptrs&#91;1] = &iocbs&#91;3];
    printf("\nPrepared 2 read requests.\n");

    // 8. 提交读取请求
    printf("Submitting read requests...\n");
    ret = io_submit(ctx, 2, iocb_ptrs);
    if (ret != 2) {
        fprintf(stderr, "io_submit (reads) failed: submitted %d, expected %d\n", ret, 2);
        if (ret < 0) perror("io_submit");
        io_destroy(ctx);
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("Submitted 2 read requests successfully.\n");

    // 9. 等待读取完成
    printf("Waiting for read completions...\n");
    ret = io_getevents(ctx, 2, 2, events, &timeout);
    if (ret < 0) {
        perror("io_getevents (reads)");
        io_destroy(ctx);
        close(fd);
        exit(EXIT_FAILURE);
    }
    if (ret < 2) {
        printf("Warning: Only got %d read events, expected 2.\n", ret);
    } else {
        printf("Received %d read completion events.\n", ret);
        for (i = 0; i < ret; ++i) {
            if (events&#91;i].res < 0) {
                fprintf(stderr, "Read error: %s\n", strerror(-events&#91;i].res));
            } else {
                printf("Read %d completed: %lld bytes read.\n", i+1, (long long)events&#91;i].res);
                // 简单验证读取的数据
                char expected_char = (i == 0) ? 'A' : 'B';
                if (((char*)(events&#91;i].data))&#91;0] == expected_char) {
                    printf("  Data verification OK for buffer %d.\n", i+1);
                } else {
                    printf("  Data verification FAILED for buffer %d.\n", i+1);
                }
            }
        }
    }

    // 10. 清理资源
    printf("\n--- Cleaning up ---\n");
    ret = io_destroy(ctx);
    if (ret < 0) {
        perror("io_destroy");
    } else {
        printf("Destroyed AIO context.\n");
    }
    close(fd);
    printf("Closed file descriptor.\n");
    unlink(filename); // 删除测试文件
    printf("Deleted test file '%s'.\n", filename);

    printf("\n--- Summary ---\n");
    printf("1. io_setup(nr_events, &ctx): Creates an AIO context that can handle 'nr_events' concurrent operations.\n");
    printf("2. io_submit(ctx_id, nr, iocb_ptrs): Submits 'nr' AIO requests (described by iocb structs) to the context.\n");
    printf("3. struct iocb: Describes a single AIO operation (read/write/fsync etc.) with all necessary parameters.\n");
    printf("4. These are the first steps in the Linux AIO workflow. Results are fetched with io_getevents().\n");
    printf("5. Note: Traditional Linux AIO has limitations. io_uring is the modern, preferred approach.\n");

    return 0;
}

# 假设代码保存在 aio_setup_submit_example.c 中
gcc -o aio_setup_submit_example aio_setup_submit_example.c

# 运行程序
./aio_setup_submit_example

--- Demonstrating io_setup and io_submit (Linux AIO) ---
Opened/created file 'aio_test_file.txt'
Initialized AIO context (ctx_id=123456789).
Prepared 2 write requests.
Submitting write requests...
Submitted 2 write requests successfully.
Waiting for write completions...
Received 2 write completion events.
Write 1 completed: 1024 bytes written.
Write 2 completed: 1024 bytes written.

Prepared 2 read requests.
Submitting read requests...
Submitted 2 read requests successfully.
Waiting for read completions...
Received 2 read completion events.
Read 1 completed: 1024 bytes read.
  Data verification OK for buffer 1.
Read 2 completed: 1024 bytes read.
  Data verification OK for buffer 2.

--- Cleaning up ---
Destroyed AIO context.
Closed file descriptor.
Deleted test file 'aio_test_file.txt'.

--- Summary ---
1. io_setup(nr_events, &ctx): Creates an AIO context that can handle 'nr_events' concurrent operations.
2. io_submit(ctx_id, nr, iocb_ptrs): Submits 'nr' AIO requests (described by iocb structs) to the context.
3. struct iocb: Describes a single AIO operation (read/write/fsync etc.) with all necessary parameters.
4. These are the first steps in the Linux AIO workflow. Results are fetched with io_getevents().
5. Note: Traditional Linux AIO has limitations. io_uring is the modern, preferred approach.

// 需要定义宏来启用 AIO 相关定义
#define _GNU_SOURCE
#include <linux/aio_abi.h> // 包含 iocb 等定义
#include <sys/syscall.h>   // 包含系统调用号
#include <unistd.h>        // 包含 syscall 函数

// io_submit 系统调用的实际接口
long syscall(SYS_io_submit, io_context_t ctx_id, long nr, struct iocb **iocbpp);

// 简化版，实际定义在 linux/aio_abi.h
struct iocb {
    __u64 aio_data;          // 用户定义的数据，用于匹配请求和完成事件
    __u32 aio_key, aio_reserved1;
    __u16 aio_lio_opcode;    // 操作类型 (IOCB_CMD_PREAD, IOCB_CMD_PWRITE, ...)
    __s16 aio_reqprio;       // 请求优先级 (通常为 0)
    __u32 aio_fildes;        // 文件描述符
    __u64 aio_buf;           // 用户空间缓冲区地址
    __u64 aio_nbytes;        // 传输字节数
    __s64 aio_offset;        // 文件偏移量
    // ... 其他字段用于高级功能
};

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include <linux/aio_abi.h>
#include <sys/syscall.h>

// 封装 io_setup 系统调用
static inline int my_io_setup(unsigned nr_events, io_context_t *ctxp) {
    return syscall(__NR_io_setup, nr_events, ctxp);
}

// 封装 io_destroy 系统调用
static inline int my_io_destroy(io_context_t ctx) {
    return syscall(__NR_io_destroy, ctx);
}

// 封装 io_submit 系统调用
static inline int my_io_submit(io_context_t ctx, long nr, struct iocb **iocbpp) {
    return syscall(__NR_io_submit, ctx, nr, iocbpp);
}

// 辅助函数：初始化一个异步写入的 iocb 结构
void prep_pwrite(struct iocb *iocb, int fd, const void *buf, size_t count, __u64 offset) {
    memset(iocb, 0, sizeof(*iocb)); // 清零结构体
    iocb->aio_lio_opcode = IOCB_CMD_PWRITE; // 设置操作类型为异步写
    iocb->aio_fildes = fd;                 // 设置文件描述符
    iocb->aio_buf = (__u64)(unsigned long)buf; // 设置缓冲区地址
    iocb->aio_nbytes = count;              // 设置写入字节数
    iocb->aio_offset = offset;             // 设置文件偏移量
    iocb->aio_data = (__u64)(unsigned long)buf; // 设置用户数据 (这里用 buf 地址)
}

int main() {
    const char *filename = "io_submit_test_file.txt";
    const int num_writes = 3;
    const size_t chunk_size = 1024;
    int fd;
    io_context_t ctx = 0; // 必须初始化为 0
    struct iocb iocbs&#91;num_writes];
    struct iocb *iocb_ptrs&#91;num_writes];
    char buffers&#91;num_writes]&#91;chunk_size];
    int ret, i;

    printf("--- Demonstrating io_submit ---\n");

    // 1. 初始化要写入的数据
    for (i = 0; i < num_writes; ++i) {
        memset(buffers&#91;i], 'A' + i, chunk_size); // Fill with 'A', 'B', 'C'
    }

    // 2. 创建并打开文件
    fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, 0644);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    printf("1. Opened/created file '%s' (fd=%d)\n", filename, fd);

    // 3. 初始化异步 I/O 上下文
    ret = my_io_setup(num_writes, &ctx);
    if (ret < 0) {
        perror("io_setup");
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("2. Initialized AIO context (ctx_id=%llu)\n", (unsigned long long)ctx);

    // 4. 准备 I/O 请求 (iocb)
    printf("3. Preparing %d asynchronous write requests...\n", num_writes);
    for (i = 0; i < num_writes; ++i) {
        prep_pwrite(&iocbs&#91;i], fd, buffers&#91;i], chunk_size, i * chunk_size);
        iocb_ptrs&#91;i] = &iocbs&#91;i];
        printf("   Prepared write %d: offset=%zu, size=%zu, data='%c'...\n",
               i+1, i * chunk_size, chunk_size, 'A' + i);
    }

    // 5. 提交 I/O 请求
    printf("4. Submitting %d write requests using io_submit...\n", num_writes);
    ret = my_io_submit(ctx, num_writes, iocb_ptrs);
    if (ret != num_writes) {
        fprintf(stderr, "   io_submit failed: submitted %d requests, expected %d\n", ret, num_writes);
        if (ret < 0) {
            perror("   io_submit error");
        } else {
            printf("   Only the first %d requests were submitted successfully.\n", ret);
        }
        // 清理并退出
        my_io_destroy(ctx);
        close(fd);
        unlink(filename);
        exit(EXIT_FAILURE);
    }

    printf("   io_submit succeeded. All %d requests submitted.\n", ret);

    // 6. 注意：此时写入操作可能仍在进行中，我们需要用 io_getevents 来等待完成
    // 这个例子只演示提交，不等待完成。
    printf("5. Note: io_submit returned immediately. The writes are happening in the background.\n");
    printf("   To get the results, you need to call io_getevents().\n");

    // 7. 清理资源 (在真实程序中，你应该在 io_getevents 确认完成后再关闭文件)
    printf("6. Cleaning up resources...\n");
    my_io_destroy(ctx);
    printf("   Destroyed AIO context.\n");
    close(fd);
    printf("   Closed file descriptor.\n");
    unlink(filename); // 删除测试文件
    printf("   Deleted test file '%s'.\n", filename);

    printf("\n--- Summary ---\n");
    printf("1. io_submit(ctx_id, nr, iocb_ptrs) submits 'nr' AIO requests to the context 'ctx_id'.\n");
    printf("2. Each request is described by an 'iocb' struct, pointed to by elements in 'iocb_ptrs'.\n");
    printf("3. It returns the number of requests successfully submitted (may be < nr on partial failure).\n");
    printf("4. It returns immediately; the I/O happens asynchronously in the background.\n");
    printf("5. Use io_getevents() afterwards to check for completion and get results.\n");

    return 0;
}

# 假设代码保存在 io_submit_example.c 中
gcc -o io_submit_example io_submit_example.c

# 运行程序
./io_submit_example

--- Demonstrating io_submit ---
1. Opened/created file 'io_submit_test_file.txt' (fd=3)
2. Initialized AIO context (ctx_id=123456789)
3. Preparing 3 asynchronous write requests...
   Prepared write 1: offset=0, size=1024, data='A'...
   Prepared write 2: offset=1024, size=1024, data='B'...
   Prepared write 3: offset=2048, size=1024, data='C'...
4. Submitting 3 write requests using io_submit...
   io_submit succeeded. All 3 requests submitted.
5. Note: io_submit returned immediately. The writes are happening in the background.
   To get the results, you need to call io_getevents().
6. Cleaning up resources...
   Destroyed AIO context.
   Closed file descriptor.
   Deleted test file 'io_submit_test_file.txt'.

--- Summary ---
1. io_submit(ctx_id, nr, iocb_ptrs) submits 'nr' AIO requests to the context 'ctx_id'.
2. Each request is described by an 'iocb' struct, pointed to by elements in 'iocb_ptrs'.
3. It returns the number of requests successfully submitted (may be < nr on partial failure).
4. It returns immediately; the I/O happens asynchronously in the background.
5. Use io_getevents() afterwards to check for completion and get resu

#define _GNU_SOURCE // 必须定义这个宏才能使用 accept4
#include <sys/socket.h> // 包含 accept4 函数声明

// accept4 是 Linux 特有的系统调用
int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);

#define _GNU_SOURCE // 必须定义以使用 accept4
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h> // 包含 O_NONBLOCK 等

#define PORT 8080
#define BACKLOG 10 // 监听队列的最大长度

void handle_client(int client_fd, const struct sockaddr_in *client_addr) {
    char buffer&#91;1024];
    ssize_t bytes_read;

    printf("Handling client %s:%d on fd %d\n",
           inet_ntoa(client_addr->sin_addr), ntohs(client_addr->sin_port), client_fd);

    // 读取客户端发送的数据
    while ((bytes_read = read(client_fd, buffer, sizeof(buffer) - 1)) > 0) {
        buffer&#91;bytes_read] = '\0';
        printf("Received from client: %s", buffer);

        // 将数据回显给客户端
        if (write(client_fd, buffer, bytes_read) != bytes_read) {
            perror("write");
            break;
        }
    }

    if (bytes_read == 0) {
        printf("Client disconnected.\n");
    } else if (bytes_read == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            printf("No data available to read (non-blocking).\n");
        } else {
            perror("read");
        }
    }

    close(client_fd); // 关闭与该客户端的连接
    printf("Closed connection to client.\n");
}

int main() {
    int server_fd, client_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);

    printf("--- Simple TCP Server using accept4 ---\n");

    // 1. 创建 socket
    // AF_INET: IPv4
    // SOCK_STREAM: TCP
    // 0: 使用默认协议 (TCP)
    server_fd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
    if (server_fd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }
    printf("Created server socket: %d\n", server_fd);

    // 2. 准备服务器地址结构
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY; // 绑定到所有本地接口
    server_addr.sin_port = htons(PORT);       // 绑定到指定端口 (网络字节序)

    // 3. 绑定 socket 到地址和端口
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("Bound server socket to port %d\n", PORT);

    // 4. 开始监听连接
    if (listen(server_fd, BACKLOG) == -1) {
        perror("listen");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("Listening for connections...\n");

    printf("Server is running. Connect to it using e.g., 'telnet 127.0.0.1 %d' or 'nc 127.0.0.1 %d'\n", PORT, PORT);
    printf("Press Ctrl+C to stop the server.\n");

    // 5. 主循环：接受连接
    while (1) {
        // 6. 使用 accept4 接受连接
        // SOCK_CLOEXEC: 自动设置 close-on-exec 标志
        // SOCK_NONBLOCK: 自动设置非阻塞模式
        client_fd = accept4(server_fd, (struct sockaddr *)&client_addr, &client_len, SOCK_CLOEXEC | SOCK_NONBLOCK);

        if (client_fd == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                // 对于阻塞的监听套接字，这不太可能发生
                // 但对于非阻塞的监听套接字，队列可能为空
                printf("No pending connections (EAGAIN/EWOULDBLOCK).\n");
                usleep(100000); // 等待 0.1 秒再试
                continue;
            } else if (errno == EINTR) {
                // 被信号中断，通常继续循环
                printf("accept4 interrupted by signal, continuing...\n");
                continue;
            } else {
                perror("accept4");
                // 对于其他严重错误，可以选择关闭服务器
                // close(server_fd);
                // exit(EXIT_FAILURE);
                continue; // 或者简单地继续尝试
            }
        }

        printf("\nAccepted new connection. Client fd: %d\n", client_fd);
        printf("Client address: %s:%d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

        // 7. 处理客户端 (在这个简单示例中，我们直接处理)
        // 注意：在实际的高性能服务器中，这里通常会 fork() 或使用线程/事件循环
        handle_client(client_fd, &client_addr);
    }

    // 8. 关闭服务器套接字 (实际上不会执行到这里)
    close(server_fd);
    printf("Server socket closed.\n");
    return 0;
}

# 假设代码保存在 tcp_server_accept4.c 中
# 必须定义 _GNU_SOURCE
gcc -D_GNU_SOURCE -o tcp_server_accept4 tcp_server_accept4.c

# 在一个终端运行服务器
./tcp_server_accept4

# 在另一个终端使用 telnet 或 nc 连接服务器
telnet 127.0.0.1 8080
# 或者
nc 127.0.0.1 8080

# 在 telnet/nc 窗口中输入一些文字，按回车，会看到服务器回显
# 输入 Ctrl+] 然后 quit (telnet) 或 Ctrl+C (nc) 来断开连接

--- Simple TCP Server using accept4 ---
Created server socket: 3
Bound server socket to port 8080
Listening for connections...
Server is running. Connect to it using e.g., 'telnet 127.0.0.1 8080' or 'nc 127.0.0.1 8080'
Press Ctrl+C to stop the server.

Accepted new connection. Client fd: 4
Client address: 127.0.0.1:54321
Handling client 127.0.0.1:54321 on fd 4
Received from client: Hello, Server!

Client disconnected.
Closed connection to client.

Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Hello, Server!
Hello, Server! # 服务器回显
^]
telnet> quit
Connection closed.

yara-flask-api/
├── app.py                  # Flask 主程序
├── rules/                  # YARA 规则目录
│   ├── hello.yar
│   └── suspicious_pe.yar
├── uploads/                # 临时存储上传文件（可选）
└── requirements.txt

flask
yara-python

pip install -r requirements.txt

rule ContainsHello
{
    strings:
        $hello = "Hello" ascii nocase
    condition:
        $hello
}

import "pe"

rule SuspiciousPEScan
{
    meta:
        description = "Detects common suspicious PE imports"

    strings:
        $create_remote_thread = "CreateRemoteThread" fullword ascii
        $write_process_memory = "WriteProcessMemory" fullword ascii

    condition:
        pe.is_pe and
        any of them
}

import os
import yara
from flask import Flask, request, jsonify
from werkzeug.utils import secure_filename

# 初始化 Flask 应用
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = 'uploads'
app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024  # 10MB 限制

# 确保目录存在
os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
os.makedirs('rules', exist_ok=True)

# 编译所有 .yar 规则
def load_yara_rules():
    try:
        rule_files = {}
        for filename in os.listdir('rules'):
            if filename.endswith('.yar'):
                filepath = os.path.join('rules', filename)
                rule_files[f"rule_{filename}"] = filepath
        rules = yara.compile(filepaths=rule_files)
        print(f"[+] 成功加载 {len(rule_files)} 条 YARA 规则")
        return rules
    except yara.Error as e:
        print(f"[-] YARA 规则编译失败: {e}")
        return None

# 全局加载规则
yara_rules = load_yara_rules()

if not yara_rules:
    print("[-] 无法启动：YARA 规则加载失败")
    exit(1)

# 根路径
@app.route('/')
def index():
    return '''
    <h3>YARA 扫描 API 服务</h3>
    <p>使用 POST /scan 上传文件进行扫描</p>
    '''

# 扫描接口
@app.route('/scan', methods=&#91;'POST'])
def scan_file():
    if 'file' not in request.files:
        return jsonify({"error": "未提供文件字段 'file'"}), 400

    file = request.files&#91;'file']
    if file.filename == '':
        return jsonify({"error": "未选择文件"}), 400

    if file:
        filename = secure_filename(file.filename)
        filepath = os.path.join(app.config&#91;'UPLOAD_FOLDER'], filename)
        file.save(filepath)

        try:
            # 执行 YARA 扫描
            matches = yara_rules.match(filepath)

            result = {
                "filename": filename,
                "matches": &#91;]
            }

            for match in matches:
                indicators = &#91;]
                for string in match.strings:
                    indicators.append({
                        "offset": f"0x{string&#91;0]:X}",
                        "identifier": string&#91;1],
                        "data": string&#91;2].decode('utf-8', errors='replace')
                    })
                result&#91;"matches"].append({
                    "rule": match.rule,
                    "tags": match.tags,
                    "indicators": indicators
                })

            os.remove(filepath)  # 扫描后删除文件（可选）
            return jsonify(result), 200

        except Exception as e:
            os.remove(filepath)
            return jsonify({"error": f"扫描出错: {str(e)}"}), 500

    return jsonify({"error": "未知错误"}), 500

# 启动服务
if __name__ == '__main__':
    print("🚀 启动 YARA 扫描服务 http://127.0.0.1:5000")
    app.run(host='0.0.0.0', port=5000, debug=False)

python app.py

echo "Hello, this is a test." > test.txt
curl -X POST -F "file=@test.txt" http://127.0.0.1:5000/scan

{
  "filename": "test.txt",
  "matches": [
    {
      "rule": "ContainsHello",
      "tags": [],
      "indicators": [
        {
          "offset": "0x0",
          "identifier": "$hello",
          "data": "Hello"
        }
      ]
    }
  ]
}

curl -X POST -F "file=@malware.exe" http://127.0.0.1:5000/scan

编写 sat.magic（纯规则） 
         ↓
    file -C -m sat.magic   → 生成 magic.mgc（二进制数据库）
         ↓
C 程序中 magic_load("magic.mgc")  → 成功加载
         ↓
调用 magic_file() → 正确识别

cd ~/satellite-analysis-asscii/smagic
nano sat.magic

# Satellite Telemetry Frame
0       belong      0xAA55CCDD
>8      string      \x01\x02\x03\x04
>8      string      SAT-TELEMETRY
# (Satellite Telemetry Packet)

# GBK Chinese Text Detection
0       byte        > 0xA0
>&0     byte        < 0xFF
>1      byte        > 0xA0
>&1     byte        < 0xFF
# (Chinese GBK Text)

file -C -m sat.magic

Creating magic.mgc from sat.magic

vim detect_encoding.c

// 原代码（错误）：
// if (magic_load(magic, NULL) != 0) { ... }

// 新代码：先加载默认库，再加载自定义库
if (magic_load(magic, NULL) != 0) {
    fprintf(stderr, "Error loading default magic: %s\n", magic_error(magic));
    magic_close(magic);
    exit(1);
}

// 加载自定义 magic.mgc
if (magic_load(magic, "./smagic/magic.mgc") != 0) {
    fprintf(stderr, "Error loading custom magic: %s\n", magic_error(magic));
    magic_close(magic);
    exit(1);
}

gcc -o a.out detect_encoding.c -lmagic

cd ~/satellite-analysis-asscii

# 生成 GBK 编码文件
echo "卫星状态：正常
时间：2025-04-05
消息：系统在线" > gbk.txt

iconv -f UTF-8 -t GBK gbk.txt > gbk.bin

./a.out gbk.bin

🔍 启动 libmagic 文本编码识别（C 语言版）
------------------------------------------------

📄 gbk.bin:
   检测编码: iso-8859-1 → ISO-8859-1（西欧）

pip3 install cchardet

#!/usr/bin/env python3
import cchardet
import sys

with open(sys.argv[1], 'rb') as f:
    raw = f.read()
result = cchardet.detect(raw)
print(f"文件: {sys.argv[1]}")
print(f"检测编码: {result['encoding']}")
print(f"置信度: {result['confidence']:.2f}")

python3 detect_gbk.py gbk.bin

检测编码: GBK
置信度: 0.99

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <string.h>

#define MAX_CLIENTS 1024
#define BUFFER_SIZE 1024

int main_select() {
    fd_set read_fds, master_fds;
    int max_fd = 0;
    int client_sockets&#91;MAX_CLIENTS] = {0};
    char buffer&#91;BUFFER_SIZE];
    
    printf("=== select 示例 ===\n");
    
    // 初始化文件描述符集合
    FD_ZERO(&master_fds);
    FD_SET(STDIN_FILENO, &master_fds);
    max_fd = STDIN_FILENO;
    
    while (1) {
        read_fds = master_fds;
        struct timeval timeout = {1, 0};  // 1秒超时
        
        int activity = select(max_fd + 1, &read_fds, NULL, NULL, &timeout);
        
        if (activity < 0) {
            if (errno == EINTR) continue;
            perror("select error");
            break;
        }
        
        if (activity == 0) {
            printf("select timeout\n");
            continue;
        }
        
        // 检查标准输入
        if (FD_ISSET(STDIN_FILENO, &read_fds)) {
            ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
            if (bytes_read > 0) {
                buffer&#91;bytes_read] = '\0';
                printf("stdin: %s", buffer);
                
                if (strncmp(buffer, "quit", 4) == 0) {
                    break;
                }
            }
        }
    }
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <poll.h>
#include <errno.h>
#include <string.h>

#define MAX_FDS 10
#define TIMEOUT_MS 5000  // 5秒超时

int main_poll() {
    struct pollfd fds&#91;MAX_FDS];
    int nfds = 1;
    char buffer&#91;1024];
    
    printf("=== poll 示例 ===\n");
    
    // 初始化 pollfd 结构
    fds&#91;0].fd = STDIN_FILENO;
    fds&#91;0].events = POLLIN;
    fds&#91;0].revents = 0;
    
    printf("监视标准输入，输入 'quit' 退出\n");
    
    while (1) {
        int ready = poll(fds, nfds, TIMEOUT_MS);
        
        if (ready == -1) {
            if (errno == EINTR) continue;
            perror("poll error");
            break;
        }
        
        if (ready == 0) {
            printf("poll timeout\n");
            continue;
        }
        
        // 处理就绪的文件描述符
        for (int i = 0; i < nfds; i++) {
            if (fds&#91;i].revents & POLLIN) {
                if (fds&#91;i].fd == STDIN_FILENO) {
                    ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
                    if (bytes_read > 0) {
                        buffer&#91;bytes_read] = '\0';
                        printf("received: %s", buffer);
                        
                        if (strncmp(buffer, "quit", 4) == 0) {
                            return 0;
                        }
                    }
                }
            }
            
            if (fds&#91;i].revents & (POLLERR | POLLHUP | POLLNVAL)) {
                printf("fd %d error\n", fds&#91;i].fd);
                return 1;
            }
        }
    }
    
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <poll.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <string.h>

volatile sig_atomic_t signal_received = 0;

void signal_handler(int sig) {
    signal_received = sig;
    printf("\nSignal %d received\n", sig);
}

int main_ppoll() {
    struct pollfd fds&#91;2];
    struct timespec timeout;
    sigset_t sigmask;
    char buffer&#91;1024];
    
    printf("=== ppoll 示例 ===\n");
    
    // 设置信号处理
    struct sigaction sa;
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
    
    // 初始化 pollfd
    fds&#91;0].fd = STDIN_FILENO;
    fds&#91;0].events = POLLIN;
    fds&#91;0].revents = 0;
    
    // 设置超时时间
    timeout.tv_sec = 3;
    timeout.tv_nsec = 0;
    
    // 设置信号屏蔽集
    sigemptyset(&sigmask);
    
    printf("Monitoring stdin with ppoll...\n");
    printf("Press Ctrl+C to send signal\n");
    printf("Type 'quit' to exit\n");
    
    while (!signal_received) {
        int ready = ppoll(fds, 1, &timeout, &sigmask);
        
        if (ready == -1) {
            if (errno == EINTR) {
                printf("ppoll interrupted by signal\n");
                if (signal_received) {
                    printf("Signal handling complete\n");
                }
                continue;
            } else {
                perror("ppoll error");
                break;
            }
        }
        
        if (ready == 0) {
            printf("ppoll timeout\n");
            continue;
        }
        
        if (fds&#91;0].revents & POLLIN) {
            ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
            if (bytes_read > 0) {
                buffer&#91;bytes_read] = '\0';
                printf("Input: %s", buffer);
                
                if (strncmp(buffer, "quit", 4) == 0) {
                    break;
                }
            }
        }
        
        fds&#91;0].revents = 0;  // 重置事件
    }
    
    printf("Program exiting normally\n");
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#define MAX_EVENTS 10
#define BUFFER_SIZE 1024

int make_socket_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        return -1;
    }
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main_epoll() {
    int epoll_fd;
    struct epoll_event ev, events&#91;MAX_EVENTS];
    char buffer&#91;BUFFER_SIZE];
    
    printf("=== epoll 示例 ===\n");
    
    // 创建 epoll 实例
    epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1");
        return 1;
    }
    
    // 设置标准输入为非阻塞
    if (make_socket_nonblocking(STDIN_FILENO) == -1) {
        perror("fcntl");
        close(epoll_fd);
        return 1;
    }
    
    // 添加标准输入到 epoll
    ev.events = EPOLLIN | EPOLLET;  // 边缘触发模式
    ev.data.fd = STDIN_FILENO;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) == -1) {
        perror("epoll_ctl: stdin");
        close(epoll_fd);
        return 1;
    }
    
    printf("epoll monitoring stdin (edge-triggered mode)\n");
    printf("Type 'quit' to exit\n");
    
    while (1) {
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, 3000);  // 3秒超时
        
        if (nfds == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait");
            break;
        }
        
        if (nfds == 0) {
            printf("epoll timeout\n");
            continue;
        }
        
        for (int n = 0; n < nfds; n++) {
            if (events&#91;n].events & EPOLLIN) {
                if (events&#91;n].data.fd == STDIN_FILENO) {
                    ssize_t bytes_read;
                    while ((bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1)) > 0) {
                        buffer&#91;bytes_read] = '\0';
                        printf("epoll input: %s", buffer);
                        
                        if (strncmp(buffer, "quit", 4) == 0) {
                            close(epoll_fd);
                            return 0;
                        }
                    }
                    
                    if (bytes_read == -1) {
                        if (errno != EAGAIN && errno != EWOULDBLOCK) {
                            perror("read");
                        }
                    }
                }
            }
            
            if (events&#91;n].events & (EPOLLERR | EPOLLHUP)) {
                printf("epoll error on fd %d\n", events&#91;n].data.fd);
                close(epoll_fd);
                return 1;
            }
        }
    }
    
    close(epoll_fd);
    return 0;
}