[C언어] 안전한 시그널 처리: Self-Pipe Trick

#ifndef SIGNAL_HANDLER_H
#define SIGNAL_HANDLER_H

#include <signal.h>

// 사용자 정의 시그널 핸들러 함수 포인터 타입
typedef void (*SignalHandler)(int signo);

// 시그널 처리 메커니즘을 초기화합니다.
int signal_init(void);

// 시그널 처리 리소스를 해제합니다.
void signal_fini(void);

// 특정 시그널(signo)에 대한 행동(handler)을 설정합니다.
int signal_set_action(int signo, SignalHandler handler);

// 시그널 이벤트를 수신하는 파이프의 읽기 fd를 반환합니다.
int signal_get_fd(void);

// 파이프로부터 시그널을 읽어 등록된 핸들러를 호출합니다.
int signal_dispatch(void);

#endif // SIGNAL_HANDLER_H

#define _GNU_SOURCE
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include "signal_handler.h"

static SignalHandler signal_handlers[NSIG];
static int pipe_fds[2] = {-1, -1};

// [핵심] 오직 시그널 번호를 파이프에 쓰는 역할만 하는 마스터 핸들러
static void master_signal_handler(int signo, siginfo_t *info, void *context) {
    (void)info;
    (void)context;
    // async-signal-safe 함수인 write()만 사용
    ssize_t written;
    do {
        written = write(pipe_fds[1], &signo, sizeof(signo));
    } while (written == -1 && errno == EINTR);
}

int signal_init(void) {
    if (pipe2(pipe_fds, O_CLOEXEC | O_NONBLOCK) == -1) {
        perror("pipe2");
        return -1;
    }
    for (int i = 0; i < NSIG; ++i) {
        signal_handlers[i] = NULL;
    }
    return 0;
}

void signal_fini(void) {
    if (pipe_fds[0] != -1) close(pipe_fds[0]);
    if (pipe_fds[1] != -1) close(pipe_fds[1]);
}

int signal_set_action(int signo, SignalHandler handler) {
    if (signo < 1 || signo >= NSIG) return -1;

    signal_handlers[signo] = handler;
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sigemptyset(&sa.sa_mask);

    if (handler == SIG_DFL || handler == SIG_IGN) {
        sa.sa_handler = handler;
        sa.sa_flags = 0;
    } else {
        sa.sa_sigaction = master_signal_handler;
        sa.sa_flags = SA_SIGINFO | SA_RESTART;
    }

    if (sigaction(signo, &sa, NULL) == -1) {
        perror("sigaction");
        return -1;
    }
    return 0;
}

int signal_get_fd(void) {
    return pipe_fds[0];
}

int signal_dispatch(void) {
    int signo;
    ssize_t bytes_read;
    int dispatched_count = 0;

    while ((bytes_read = read(pipe_fds[0], &signo, sizeof(signo))) > 0) {
        if (bytes_read == sizeof(signo)) {
            SignalHandler handler = signal_handlers[signo];
            if (handler && handler != SIG_DFL && handler != SIG_IGN) {
                handler(signo);
                dispatched_count++;
            }
        }
    }
    return dispatched_count;
}

#include <stdio.h>
#include <unistd.h>
#include <poll.h>
#include <stdlib.h>
#include "signal_handler.h"

volatile sig_atomic_t running = 1;

// SIGINT (Ctrl+C)에 대한 사용자 정의 핸들러
void handle_sigint(int signo) {
    printf("\nCaught signal %d (SIGINT). Shutting down...\n", signo);
    running = 0;
}

// SIGTERM에 대한 사용자 정의 핸들러
void handle_sigterm(int signo) {
    printf("\nCaught signal %d (SIGTERM). Shutting down gracefully...\n", signo);
    running = 0;
}

int main(void) {
    printf("Starting... PID: %d\n", getpid());

    if (signal_init() != 0) {
        return EXIT_FAILURE;
    }

    signal_set_action(SIGINT, handle_sigint);
    signal_set_action(SIGTERM, handle_sigterm);
    signal_set_action(SIGPIPE, SIG_IGN); // SIGPIPE는 무시

    struct pollfd pfd;
    pfd.fd = signal_get_fd();
    pfd.events = POLLIN;

    while (running) {
        printf("Waiting for a signal or other events...\n");
        int ret = poll(&pfd, 1, -1); // 무한 대기

        if (ret > 0 && (pfd.revents & POLLIN)) {
            printf("Signal event detected. Dispatching...\n");
            signal_dispatch();
        }
    }

    printf("Cleaning up and exiting.\n");
    signal_fini();
    return EXIT_SUCCESS;
}