Linux 编程接口（The Linux Programming Interface）详解

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
 
int main() {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed"); // 必须检查错误
        exit(EXIT_FAILURE);
    }
 
    if (pid == 0) { // 子进程
        printf("子进程 PID: %d, 父进程 PPID: %d\n", getpid(), getppid());
        execlp("ls", "ls", "-l", NULL); // 执行 ls -l
        // 如果 execlp 失败，才会执行下面的代码
        perror("execlp failed");
        exit(EXIT_FAILURE);
    } else { // 父进程
        int status;
        // 等待 PID 为 pid 的子进程，阻塞并获取退出状态
        if (waitpid(pid, &status, 0) == -1) {
            perror("waitpid failed");
            exit(EXIT_FAILURE);
        }
        if (WIFEXITED(status)) { // 子进程正常退出
            printf("子进程退出，状态码: %d\n", WEXITSTATUS(status));
        }
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
 
#define BUF_SIZE 4096 // 4KB 缓冲区，匹配系统页大小
 
int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "用法: %s <源文件> <目标文件>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
 
    int src_fd = open(argv[1], O_RDONLY);
    if (src_fd == -1) {
        perror("open 源文件失败");
        exit(EXIT_FAILURE);
    }
 
    // 创建目标文件，权限 0644（rw-r--r--），并设置 O_CLOEXEC
    int dest_fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
    if (dest_fd == -1) {
        perror("open 目标文件失败");
        close(src_fd); // 出错时需关闭已打开的 FD
        exit(EXIT_FAILURE);
    }
 
    char buf[BUF_SIZE];
    ssize_t n;
    while ((n = read(src_fd, buf, BUF_SIZE)) > 0) { // 循环读取直到 EOF
        ssize_t total_written = 0;
        while (total_written < n) { // 处理部分写入
            ssize_t written = write(dest_fd, buf + total_written, n - total_written);
            if (written == -1) {
                perror("write 失败");
                close(src_fd);
                close(dest_fd);
                exit(EXIT_FAILURE);
            }
            total_written += written;
        }
    }
 
    if (n == -1) { // 检查 read 错误
        perror("read 失败");
        exit(EXIT_FAILURE);
    }
 
    // 关闭 FD（即使程序退出会自动关闭，显式关闭是良好习惯）
    if (close(src_fd) == -1 || close(dest_fd) == -1) {
        perror("close 失败");
        exit(EXIT_FAILURE);
    }
 
    printf("文件复制成功\n");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
 
int main() {
    int pipefd[2]; // pipefd[0] 读端，pipefd[1] 写端
    if (pipe(pipefd) == -1) { // 创建管道
        perror("pipe failed");
        exit(EXIT_FAILURE);
    }
 
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }
 
    if (pid == 0) { // 子进程：写数据到管道，读父进程回复
        close(pipefd[0]); // 关闭子进程不需要的读端
 
        const char *msg = "Hello from child!";
        write(pipefd[1], msg, strlen(msg));
        close(pipefd[1]); // 写完关闭写端，父进程读端会收到 EOF
 
        // 假设另一个管道用于父进程回复，此处简化，实际需创建双向管道
        printf("子进程发送完成\n");
        exit(EXIT_SUCCESS);
    } else { // 父进程：读子进程数据
        close(pipefd[1]); // 关闭父进程不需要的写端
 
        char buf[1024];
        ssize_t n = read(pipefd[0], buf, sizeof(buf)-1);
        if (n == -1) {
            perror("read failed");
            exit(EXIT_FAILURE);
        }
        buf[n] = '\0'; // 确保字符串结束
        printf("父进程收到: %s\n", buf);
 
        close(pipefd[0]);
        wait(NULL); // 等待子进程退出
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
 
void sigint_handler(int signum) {
    // 仅使用异步安全函数（如 write）
    const char *msg = "捕获到 SIGINT，程序将在 3 秒后退出...\n";
    write(STDOUT_FILENO, msg, strlen(msg));
    sleep(3); // 演示清理操作（实际应尽量简短）
    exit(EXIT_SUCCESS);
}
 
int main() {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = sigint_handler; // 设置处理函数
    // 信号处理期间屏蔽所有信号（sa_mask 为信号集）
    sigfillset(&sa.sa_mask);
    sa.sa_flags = 0; // 无特殊标志
 
    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction failed");
        exit(EXIT_FAILURE);
    }
 
    printf("程序运行中，按 Ctrl+C 测试信号处理...\n");
    while (1) {
        pause(); // 等待信号
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
#define NUM_THREADS 5
#define COUNT_LIMIT 100000
 
int counter = 0;
pthread_mutex_t mutex; // 互斥锁
 
void *thread_func(void *arg) {
    int thread_id = *(int *)arg;
    free(arg); // 释放动态分配的线程 ID
 
    for (int i = 0; i < COUNT_LIMIT; i++) {
        pthread_mutex_lock(&mutex); // 加锁
        counter++; // 临界区：修改共享变量
        pthread_mutex_unlock(&mutex); // 解锁
    }
 
    printf("线程 %d 完成，计数器值: %d\n", thread_id, counter);
    pthread_exit(NULL);
}
 
int main() {
    pthread_t threads[NUM_THREADS];
    pthread_mutex_init(&mutex, NULL); // 初始化互斥锁
 
    for (int i = 0; i < NUM_THREADS; i++) {
        int *thread_id = malloc(sizeof(int));
        *thread_id = i;
        if (pthread_create(&threads[i], NULL, thread_func, thread_id) != 0) {
            perror("pthread_create failed");
            exit(EXIT_FAILURE);
        }
    }
 
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL); // 等待所有线程
    }
 
    printf("最终计数器值: %d（预期: %d）\n", counter, NUM_THREADS * COUNT_LIMIT);
    pthread_mutex_destroy(&mutex); // 销毁互斥锁
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
 
#define PORT 8080
#define BUFFER_SIZE 1024
 
int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
 
    // 创建 TCP 套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
 
    // 设置套接字选项（允许端口复用）
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }
 
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY; // 绑定所有网卡
    address.sin_port = htons(PORT); // 端口转换为网络字节序（大端）
 
    // 绑定套接字到端口 8080
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
 
    // 监听连接（等待队列长度 3）
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }
 
    printf("TCP 服务器启动，监听端口 %d...\n", PORT);
 
    // 接受客户端连接
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept");
        exit(EXIT_FAILURE);
    }
 
    // 读取客户端数据
    ssize_t valread = read(new_socket, buffer, BUFFER_SIZE);
    printf("收到客户端消息: %s\n", buffer);
 
    // 发送响应
    const char *response = "Hello from server";
    send(new_socket, response, strlen(response), 0);
    printf("响应已发送\n");
 
    close(new_socket);
    close(server_fd);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
 
int main() {
    const char *filename = "secure_file.txt";
 
    // 创建文件时设置安全权限（仅用户可读写，组和其他无权限）
    FILE *fp = fopen(filename, "w");
    if (!fp) {
        perror("fopen failed");
        exit(EXIT_FAILURE);
    }
    fclose(fp);
 
    // 修改权限为 0600（rw-------）
    if (chmod(filename, 0600) == -1) {
        perror("chmod failed");
        exit(EXIT_FAILURE);
    }
 
    printf("文件 %s 权限设置为 0600（仅所有者可读写）\n", filename);
    return 0;
}