/*
 * sigaction_basic.c - 使用 sigaction() 处理信号
 * 编译: gcc -Wall -o sigaction_basic sigaction_basic.c
 * 运行: ./sigaction_basic  (然后按 Ctrl+C)
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

static volatile sig_atomic_t g_sigint_count = 0;
static volatile sig_atomic_t g_running = 1;

static void sigint_handler(int sig)
{
    (void)sig;
    g_sigint_count++;
    /* 异步信号安全函数非常有限，write() 是安全的 */
    const char msg[] = "\n[信号] 收到 SIGINT (Ctrl+C)\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1);

    if (g_sigint_count >= 3) {
        g_running = 0;
    }
}

static void sigterm_handler(int sig)
{
    (void)sig;
    const char msg[] = "\n[信号] 收到 SIGTERM，正在退出...\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1);
    g_running = 0;
}

int main(void)
{
    struct sigaction sa_int, sa_term;

    /* 处理 SIGINT (Ctrl+C) */
    sa_int.sa_handler = sigint_handler;
    sigemptyset(&sa_int.sa_mask);     /* 处理期间不额外阻塞信号 */
    sa_int.sa_flags = SA_RESTART;     /* 被中断的系统调用自动重启 */
    sigaction(SIGINT, &sa_int, NULL);

    /* 处理 SIGTERM */
    sa_term.sa_handler = sigterm_handler;
    sigemptyset(&sa_term.sa_mask);
    sa_term.sa_flags = 0;
    sigaction(SIGTERM, &sa_term, NULL);

    printf("PID=%d: 按 Ctrl+C 3 次或 kill %d 退出\n",
           getpid(), getpid());

    while (g_running) {
        pause();  /* 挂起等待信号 */
        printf("  SIGINT 计数: %d\n", g_sigint_count);
    }

    printf("程序正常退出\n");
    return EXIT_SUCCESS;
}

struct sigaction {
    union {
        void (*sa_handler)(int);           /* 简单处理函数 */
        void (*sa_sigaction)(int, siginfo_t *, void *);  /* 详细处理函数 */
    };
    sigset_t    sa_mask;    /* 处理期间额外阻塞的信号集 */
    int         sa_flags;   /* 行为标志 */
    void        (*sa_restorer)(void);  /* 内部使用，勿设置 */
};

/*
 * sigset_demo.c - 信号集操作演示
 * 编译: gcc -Wall -o sigset_demo sigset_demo.c
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <signal.h>

static void print_sigset(const sigset_t *set)
{
    for (int sig = 1; sig < NSIG; sig++) {
        if (sigismember(set, sig)) {
            printf("  SIG %d", sig);
            /* 获取信号名称 */
            const char *name = "unknown";
            switch (sig) {
                case SIGHUP:  name = "SIGHUP"; break;
                case SIGINT:  name = "SIGINT"; break;
                case SIGQUIT: name = "SIGQUIT"; break;
                case SIGKILL: name = "SIGKILL"; break;
                case SIGTERM: name = "SIGTERM"; break;
                case SIGUSR1: name = "SIGUSR1"; break;
                case SIGCHLD: name = "SIGCHLD"; break;
            }
            printf(" (%s)\n", name);
        }
    }
}

int main(void)
{
    sigset_t set, old_set;

    /* 获取当前信号掩码 */
    sigprocmask(SIG_BLOCK, NULL, &old_set);
    printf("当前阻塞的信号:\n");
    print_sigset(&old_set);

    /* 创建自定义信号集 */
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGUSR1);
    sigaddset(&set, SIGTERM);

    printf("\n自定义信号集:\n");
    print_sigset(&set);

    /* 检查信号是否在集合中 */
    printf("\nSIGINT 在集合中? %s\n",
           sigismember(&set, SIGINT) ? "是" : "否");
    printf("SIGHUP 在集合中? %s\n",
           sigismember(&set, SIGHUP) ? "是" : "否");

    return 0;
}

/* 临时阻塞 SIGINT */
sigset_t block_set, old_set;
sigemptyset(&block_set);
sigaddset(&block_set, SIGINT);
sigprocmask(SIG_BLOCK, &block_set, &old_set);

/* 此期间 SIGINT 被挂起 */
/* ... 临界区代码 ... */

/* 恢复原来的信号掩码（SIGINT 可能被递送） */
sigprocmask(SIG_SETMASK, &old_set, NULL);

/*
 * sigqueue_demo.c - 使用 sigqueue() 发送带数据的信号
 * 编译: gcc -Wall -o sigqueue_demo sigqueue_demo.c
 * 运行: 在终端 A 运行 ./sigqueue_demo
 *        在终端 B 发送: kill -USR1 <PID>
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

static volatile sig_atomic_t g_running = 1;

static void sigusr1_handler(int sig, siginfo_t *info, void *context)
{
    (void)sig;
    (void)context;

    const char msg[] = "[SA_SIGINFO] 收到信号\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1);

    /* 获取信号发送者 PID */
    char buf[128];
    int len = snprintf(buf, sizeof(buf),
        "  发送者 PID: %d\n"
        "  发送者 UID: %d\n"
        "  附加数据 (int): %d\n",
        info->si_pid,
        info->si_uid,
        info->si_value.sival_int);
    write(STDOUT_FILENO, buf, len);
}

int main(void)
{
    struct sigaction sa;
    sa.sa_sigaction = sigusr1_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO;  /* 使用三参数处理函数 */
    sigaction(SIGUSR1, &sa, NULL);

    printf("PID=%d: 等待 SIGUSR1 信号（带数据）...\n", getpid());
    printf("  使用: kill -USR1 %d\n", getpid());
    printf("  或:   kill -10 %d\n", getpid());

    while (g_running)
        pause();

    return 0;
}

/* 向目标进程发送带整数数据的信号 */
pid_t target_pid = 12345;
union sigval value;
value.sival_int = 42;
sigqueue(target_pid, SIGUSR1, value);

/* 推荐模式：使用 SA_RESTART 处理慢速系统调用 */
struct sigaction sa;
sa.sa_handler = handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;  /* 关键：自动重启被中断的系统调用 */
sigaction(SIGINT, &sa, NULL);

/* 即使 read() 被信号中断，也会自动重试 */
ssize_t n = read(fd, buf, sizeof(buf));
/* 不需要手动检查 EINTR */

/* 手动重试模式 */
ssize_t safe_read(int fd, void *buf, size_t count)
{
    ssize_t n;
    do {
        n = read(fd, buf, count);
    } while (n == -1 && errno == EINTR);
    return n;
}

/*
 * sigchld_handler.c - 使用 SIGCHLD 信号回收子进程
 * 编译: gcc -Wall -o sigchld_handler sigchld_handler.c
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>

static volatile sig_atomic_t g_child_count = 0;

static void sigchld_handler(int sig)
{
    (void)sig;

    /* 使用 waitpid(-1, WNOHANG) 回收所有已终止的子进程 */
    /* 必须循环：多个子进程可能同时终止 */
    int saved_errno = errno;
    pid_t pid;
    int status;
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        g_child_count++;
        /* 异步信号安全函数：write() */
        char buf[128];
        int len = snprintf(buf, sizeof(buf),
            "[SIGCHLD] 回收子进程 PID=%d, 退出码=%d\n",
            pid, WIFEXITED(status) ? WEXITSTATUS(status) : -1);
        write(STDOUT_FILENO, buf, len);
    }
    errno = saved_errno;
}

int main(void)
{
    struct sigaction sa;
    sa.sa_handler = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
    sigaction(SIGCHLD, &sa, NULL);

    /* 创建多个子进程 */
    for (int i = 0; i < 3; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            /* 子进程 */
            sleep(1 + i);
            _exit(i);
        }
        printf("创建子进程 PID=%d\n", pid);
    }

    /* 父进程继续工作，不阻塞等待 */
    while (g_child_count < 3) {
        printf("父进程工作中... (已回收 %d 个子进程)\n", g_child_count);
        sleep(1);
    }

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

/*
 * graceful_shutdown.c - 使用信号实现优雅关闭
 * 编译: gcc -Wall -o graceful_shutdown graceful_shutdown.c
 */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

static volatile sig_atomic_t g_shutdown = 0;
static volatile sig_atomic_t g_reload = 0;

static void handle_signal(int sig)
{
    switch (sig) {
    case SIGTERM:
    case SIGINT:
        g_shutdown = 1;
        break;
    case SIGHUP:
        g_reload = 1;
        break;
    }
}

static void setup_signals(void)
{
    struct sigaction sa;
    sa.sa_handler = handle_signal;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;

    sigaction(SIGTERM, &sa, NULL);  /* kill <PID> */
    sigaction(SIGINT,  &sa, NULL);  /* Ctrl+C */
    sigaction(SIGHUP,  &sa, NULL);  /* kill -HUP <PID> */
}

int main(void)
{
    setup_signals();
    printf("服务启动, PID=%d\n", getpid());
    printf("  kill %d       → 优雅关闭\n", getpid());
    printf("  kill -HUP %d  → 重载配置\n", getpid());

    while (!g_shutdown) {
        if (g_reload) {
            g_reload = 0;
            printf("[信号] 收到 SIGHUP，重新加载配置...\n");
            /* 模拟重载 */
        }

        /* 模拟处理请求 */
        printf("处理请求...\n");
        sleep(2);
    }

    printf("\n正在优雅关闭...\n");
    /* 清理资源：关闭连接、写入状态等 */
    printf("资源已清理，服务关闭\n");
    return EXIT_SUCCESS;
}