/*
 * fork_basic.c - fork() 基础示例
 * 编译: gcc -Wall -o fork_basic fork_basic.c
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(void)
{
    pid_t pid;
    int parent_var = 100;

    printf("[父进程] PID=%d, PPID=%d\n", getpid(), getppid());

    pid = fork();
    if (pid == -1) {
        perror("fork");
        return EXIT_FAILURE;
    }

    if (pid == 0) {
        /* 子进程代码 */
        parent_var += 50;  /* 修改副本，不影响父进程 */
        printf("[子进程] PID=%d, PPID=%d, parent_var=%d\n",
               getpid(), getppid(), parent_var);
        return 42;  /* 子进程退出码 */
    } else {
        /* 父进程代码 */
        printf("[父进程] 创建了子进程 PID=%d, parent_var=%d\n",
               pid, parent_var);

        /* 等待子进程结束 */
        int status;
        pid_t child_pid = waitpid(pid, &status, 0);
        if (child_pid == -1) {
            perror("waitpid");
            return EXIT_FAILURE;
        }

        if (WIFEXITED(status)) {
            printf("[父进程] 子进程 %d 退出，状态码=%d\n",
                   child_pid, WEXITSTATUS(status));
        } else if (WIFSIGNALED(status)) {
            printf("[父进程] 子进程被信号 %d 终止\n",
                   WTERMSIG(status));
        }
    }

    return EXIT_SUCCESS;
}

$ ./fork_basic
[父进程] PID=1234, PPID=1000
[父进程] 创建了子进程 PID=1235, parent_var=100
[子进程] PID=1235, PPID=1234, parent_var=150
[父进程] 子进程 1235 退出，状态码=42

/*
 * fork_exec.c - fork() + execvp() 执行外部命令
 * 编译: gcc -Wall -o fork_exec fork_exec.c
 * 用法: ./fork_exec ls -la /tmp
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char *argv[])
{
    if (argc < 2) {
        fprintf(stderr, "用法: %s <命令> [参数...]\n", argv[0]);
        return EXIT_FAILURE;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return EXIT_FAILURE;
    }

    if (pid == 0) {
        /* 子进程：执行命令 */
        /* argv[1..] 作为命令和参数 */
        execvp(argv[1], &argv[1]);
        /* 如果 execvp 返回，说明出错 */
        perror(argv[1]);
        _exit(127);  /* 命令未找到 */
    } else {
        /* 父进程：等待子进程 */
        int status;
        if (waitpid(pid, &status, 0) == -1) {
            perror("waitpid");
            return EXIT_FAILURE;
        }
        if (WIFEXITED(status))
            return WEXITSTATUS(status);
        return 1;
    }
}

$ ./fork_exec ls -la /tmp
total 48
drwxrwxrwt 15 root root 4096 May 10 10:00 .
drwxr-xr-x 20 root root 4096 Jan  1 00:00 ..
...

/*
 * multi_children.c - 创建多个子进程并等待
 * 编译: gcc -Wall -o multi_children multi_children.c
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM_CHILDREN 5

int main(void)
{
    pid_t children[NUM_CHILDREN];

    /* 创建 5 个子进程 */
    for (int i = 0; i < NUM_CHILDREN; i++) {
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            return EXIT_FAILURE;
        }
        if (pid == 0) {
            /* 子进程：模拟工作 */
            printf("  子进程 %d (PID=%d) 开始工作\n", i, getpid());
            sleep(1 + i);  /* 模拟不同耗时 */
            printf("  子进程 %d (PID=%d) 完成\n", i, getpid());
            _exit(i);  /* 以索引作为退出码 */
        }
        children[i] = pid;
        printf("创建子进程 %d, PID=%d\n", i, pid);
    }

    /* 等待所有子进程 */
    printf("\n等待所有子进程完成...\n");
    for (int i = 0; i < NUM_CHILDREN; i++) {
        int status;
        pid_t pid = waitpid(children[i], &status, 0);
        if (pid == -1) {
            perror("waitpid");
            continue;
        }
        if (WIFEXITED(status)) {
            printf("子进程 PID=%d 退出码=%d\n",
                   pid, WEXITSTATUS(status));
        }
    }

    printf("所有子进程已回收\n");
    return EXIT_SUCCESS;
}

/*
 * daemon.c - 创建 POSIX 守护进程
 * 编译: gcc -Wall -o daemon daemon.c
 * 运行: ./daemon; sleep 2; cat /tmp/posix_daemon.log; kill $(cat /tmp/posix_daemon.pid)
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>

static volatile sig_atomic_t running = 1;

static void handle_signal(int sig)
{
    (void)sig;
    running = 0;
}

static int create_daemon(void)
{
    /* 第一次 fork：脱离终端 */
    pid_t pid = fork();
    if (pid == -1) return -1;
    if (pid > 0) _exit(EXIT_SUCCESS);  /* 父进程退出 */

    /* 创建新会话 */
    if (setsid() == -1) return -1;

    /* 第二次 fork：防止重新获取控制终端 */
    pid = fork();
    if (pid == -1) return -1;
    if (pid > 0) _exit(EXIT_SUCCESS);

    /* 设置文件权限掩码 */
    umask(0);

    /* 切换到根目录 */
    if (chdir("/") == -1) return -1;

    /* 关闭标准文件描述符，重定向到 /dev/null */
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    open("/dev/null", O_RDONLY);  /* stdin */
    open("/dev/null", O_WRONLY);  /* stdout */
    open("/dev/null", O_WRONLY);  /* stderr */

    return 0;
}

int main(void)
{
    if (create_daemon() == -1) {
        perror("create_daemon");
        return EXIT_FAILURE;
    }

    /* 设置信号处理 */
    signal(SIGTERM, handle_signal);
    signal(SIGINT, handle_signal);

    /* 写入 PID 文件 */
    FILE *f = fopen("/tmp/posix_daemon.pid", "w");
    if (f) { fprintf(f, "%d\n", getpid()); fclose(f); }

    /* 守护进程主循环 */
    f = fopen("/tmp/posix_daemon.log", "a");
    while (running) {
        if (f) {
            time_t now = time(NULL);
            fprintf(f, "[%ld] daemon running, PID=%d\n",
                    (long)now, getpid());
            fflush(f);
        }
        sleep(5);
    }

    if (f) {
        fprintf(f, "daemon shutting down\n");
        fclose(f);
    }
    unlink("/tmp/posix_daemon.pid");

    return EXIT_SUCCESS;
}

/*
 * env_ops.c - POSIX 环境变量操作
 * 编译: gcc -Wall -o env_ops env_ops.c
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

extern char **environ;  /* POSIX 定义的全局环境变量数组 */

int main(void)
{
    /* 1. 获取环境变量 */
    const char *path = getenv("PATH");
    printf("PATH = %s\n\n", path ? path : "(未设置)");

    /* 2. 设置环境变量 */
    setenv("MY_VAR", "hello_posix", 1);  /* 1 = 覆盖已有值 */
    printf("MY_VAR = %s\n", getenv("MY_VAR"));

    /* 3. 修改环境变量 */
    setenv("MY_VAR", "modified", 1);
    printf("MY_VAR (修改后) = %s\n", getenv("MY_VAR"));

    /* 4. 删除环境变量 */
    unsetenv("MY_VAR");
    printf("MY_VAR (删除后) = %s\n", getenv("MY_VAR"));

    /* 5. 遍历所有环境变量（前 5 个） */
    printf("\n前 5 个环境变量:\n");
    for (int i = 0; environ[i] && i < 5; i++)
        printf("  [%d] %s\n", i, environ[i]);

    return 0;
}

/*
 * parallel_exec.c - 并行执行多个命令
 * 编译: gcc -Wall -o parallel_exec parallel_exec.c
 * 用法: ./parallel_exec "sleep 2" "sleep 1" "echo done"
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

static pid_t run_command(const char *cmd)
{
    pid_t pid = fork();
    if (pid == -1) { perror("fork"); return -1; }
    if (pid == 0) {
        execl("/bin/sh", "sh", "-c", cmd, (char *)NULL);
        perror("execl");
        _exit(127);
    }
    return pid;
}

int main(int argc, char *argv[])
{
    if (argc < 2) {
        fprintf(stderr, "用法: %s \"cmd1\" \"cmd2\" ...\n", argv[0]);
        return 1;
    }

    pid_t *pids = malloc(sizeof(pid_t) * (argc - 1));
    if (!pids) { perror("malloc"); return 1; }

    /* 并行启动所有命令 */
    for (int i = 1; i < argc; i++) {
        pids[i - 1] = run_command(argv[i]);
        if (pids[i - 1] > 0)
            printf("启动: \"%s\" (PID=%d)\n", argv[i], pids[i - 1]);
    }

    /* 等待所有命令完成 */
    int failed = 0;
    for (int i = 0; i < argc - 1; i++) {
        if (pids[i] <= 0) continue;
        int status;
        waitpid(pids[i], &status, 0);
        if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
            fprintf(stderr, "PID=%d 退出码=%d\n",
                    pids[i], WEXITSTATUS(status));
            failed++;
        }
    }

    printf("\n完成: %d/%d 成功\n", argc - 1 - failed, argc - 1);
    free(pids);
    return failed ? 1 : 0;
}