/* <signal.h> 의 표준 부분 — 세 가지 처리 방식과 raise. */
#include <signal.h>
#include <stdio.h>
#include <string.h>

/* 표준이 허락하는 처리기의 몸통은 이만큼이다:
   volatile sig_atomic_t 에 값을 대입하는 것. 그 밖은 계약 밖이다. */
static volatile sig_atomic_t got_int;
static volatile sig_atomic_t got_term;

static void on_signal(int sig)
{
    if (sig == SIGINT)  got_int  = 1;
    if (sig == SIGTERM) got_term = 1;
    /* 여기서 printf 를 부르지 않는다 — 이유는 본문에서 */
}

static const char *disposition(void (*h)(int))
{
    if (h == SIG_DFL) return "SIG_DFL (default handling)";
    if (h == SIG_IGN) return "SIG_IGN (ignored)";
    if (h == SIG_ERR) return "SIG_ERR (installation failed)";
    return "our own handler";
}

int main(void)
{
    /* ── ① 설치 — 돌려주는 값은 *이전* 처리 방식이다 ───────────── */
    void (*prev)(int) = signal(SIGINT, on_signal);
    printf("return value of signal(SIGINT, on_signal) = %s\n", disposition(prev));

    /* ── ② raise — 자기 자신에게 신호를 보낸다 ─────────────────── */
    printf("before raise(SIGINT): got_int = %d\n", (int)got_int);
    int r = raise(SIGINT);
    printf("raise returned %d (0 means success), got_int = %d\n", r, (int)got_int);

    /* ── ③ 무시 — SIG_IGN 을 걸면 신호가 사라진다 ──────────────── */
    (void)signal(SIGTERM, SIG_IGN);
    (void)raise(SIGTERM);
    printf("raise(SIGTERM) after SIG_IGN: got_term = %d (still 0)\n",
           (int)got_term);

    /* ── ④ 처리 뒤에 처리기가 남는가? — 구현 정의다(표준 §7.14.1.1) ── */
    void (*was)(int) = signal(SIGINT, prev);
    printf("\nafter handling one signal, what is installed: %s\n", disposition(was));
    printf("  -> this implementation resets to SIG_DFL right after handling (the old System V way).\n");
    printf("  -> the standard allows either, so portable code either reinstalls inside\n");
    printf("     the handler or uses POSIX sigaction.\n");

    /* ── ⑤ 표준이 정한 신호는 여섯 개뿐 ───────────────────────── */
    struct { int num; const char *name; const char *meaning; } table[] = {
        { SIGABRT, "SIGABRT", "abnormal termination (abort)" },
        { SIGFPE,  "SIGFPE",  "arithmetic error (division by zero and such)" },
        { SIGILL,  "SIGILL",  "invalid instruction" },
        { SIGINT,  "SIGINT",  "interactive attention signal (Ctrl+C)" },
        { SIGSEGV, "SIGSEGV", "invalid memory access" },
        { SIGTERM, "SIGTERM", "termination request" },
    };
    printf("\nthe %zu signals the standard defines:\n", sizeof table / sizeof *table);
    for (size_t i = 0; i < sizeof table / sizeof *table; i++)
        printf("  %-8s = %2d   %s\n", table[i].name, table[i].num, table[i].meaning);

    printf("\nsizeof(sig_atomic_t) = %zu bytes\n", sizeof(sig_atomic_t));
    return 0;
}

/* 신호는 무엇을 저장하고 무엇을 되돌리는가 — 레지스터 문맥과 errno. */
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

static volatile sig_atomic_t hits;

/* ── ① errno 를 챙기지 않는 처리기 ─────────────────────────────
   write 는 처리기에서 쓸 수 있는 몇 안 되는 함수지만, 실패하면 errno 를
   바꾼다. 주 흐름이 그 값을 보기 직전이었다면 진단이 통째로 뒤집힌다. */
static void careless(int sig)
{
    (void)sig;
    hits++;
    ssize_t n = write(-1, "", 1);   /* 반드시 실패한다 — errno = EBADF */
    (void)n;
}

/* ── ② errno 를 저장하고 복원하는 처리기 ─────────────────────── */
static void careful(int sig)
{
    int saved = errno;              /* 들어오자마자 챙긴다 */
    (void)sig;
    hits++;
    ssize_t n = write(-1, "", 1);
    (void)n;
    errno = saved;                  /* 나가기 직전에 되돌린다 */
}

/* ── 레지스터에 얹혀 도는 계산. 중간에 신호를 맞아도 결과가 같은가? ── */
static long compute(int interrupt_at)
{
    long acc = 0;
    for (int i = 1; i <= 1000; i++) {
        acc += (long)i * i % 7;
        if (i == interrupt_at) raise(SIGUSR1);
    }
    return acc;
}

static int fails(void)              /* errno 를 ENOENT 로 만들어 두는 실패 */
{
    errno = 0;
    return access("/no/such/file/here", F_OK);
}

int main(void)
{
    /* ① errno 오염 */
    signal(SIGUSR1, careless);
    (void)fails();
    int before = errno;
    raise(SIGUSR1);
    printf("a handler that does not save errno: before %d(%s) -> after %d(%s)\n",
           before, strerror(before), errno, strerror(errno));

    /* ② 저장·복원 */
    signal(SIGUSR1, careful);
    (void)fails();
    before = errno;
    raise(SIGUSR1);
    printf("a handler that does save errno:     before %d(%s) -> after %d(%s)\n",
           before, strerror(before), errno, strerror(errno));

    /* ③ 계산 도중에 끼어들어도 결과가 같다.
       이 구현은 처리 뒤 SIG_DFL 로 되돌아가므로(76장) 다시 걸어 준다. */
    signal(SIGUSR1, careful);
    hits = 0;
    long quiet = compute(0);            /* 신호 없이 */
    long hit   = compute(500);          /* 한복판에서 한 번 맞고 */
    printf("\nvalue computed undisturbed = %ld\n", quiet);
    printf("value computed while hit by a signal at iteration 500 = %ld  (handler called %d times)\n",
           hit, (int)hits);
    puts(quiet == hit ? "the same - the kernel saved every register and gave them back"
                      : "different - this should not happen");

    puts("\nthis is where it differs from setjmp/longjmp (chapter 77):");
    puts("  a signal: the kernel saves and restores the *whole* register set ->");
    puts("        you can return into the middle of an expression and the arithmetic continues.");
    puts("  longjmp: a jmp_buf holds only the *callee-saved* registers ->");
    puts("        locals that lived in the other registers snap back to their old values.");
    return 0;
}

/* 처리기가 해야 할 일은 하나뿐 — 깃발을 세우고 즉시 돌아간다. */
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>          /* write — 처리기 안에서 쓸 수 있는 몇 안 되는 것 */

static volatile sig_atomic_t stop_requested;
static volatile sig_atomic_t reload_requested;
static volatile sig_atomic_t last_signal;

static void on_signal(int sig)
{
    last_signal = sig;
    if (sig == SIGTERM || sig == SIGINT) stop_requested = 1;
    if (sig == SIGUSR1)                  reload_requested = 1;

    /* 표준이 허락하는 것은 여기까지다. 아래 write 는 POSIX 가 따로 허락한
       비동기-신호-안전 함수라서 예외적으로 쓸 수 있다(본문 참조). */
    static const char note[] = "  [handler] flag set\n";
    ssize_t n = write(STDOUT_FILENO, note, sizeof note - 1);
    (void)n;
}

/* 서버의 뼈대 — 일하다가, 깃발을 보고, 결정한다 */
static void serve(void)
{
    int served = 0;
    for (;;) {
        if (reload_requested) {
            reload_requested = 0;
            printf("  re-reading the configuration (SIGUSR1)\n");
            fflush(stdout);
        }
        if (stop_requested) {
            printf("  cleaning up and going down (after handling %d)\n", served);
            return;
        }
        served++;
        if (served == 2) (void)raise(SIGUSR1);   /* 재적재 요청을 흉내 낸다 */
        if (served == 4) (void)raise(SIGTERM);   /* 종료 요청을 흉내 낸다 */
    }
}

int main(void)
{
    /* 이 구현은 처리 뒤 SIG_DFL 로 되돌리므로, 매번 다시 건다.
       (그래서 POSIX 코드는 sigaction 을 쓴다 — 다음 예제) */
    if (signal(SIGUSR1, on_signal) == SIG_ERR) return 1;
    if (signal(SIGTERM, on_signal) == SIG_ERR) return 1;

    puts("server loop starting");
    fflush(stdout);   /* 처리기의 write 는 버퍼를 거치지 않는다 — 순서를 맞춘다 */
    serve();
    printf("number of the last signal received = %d\n", (int)last_signal);

    /* 처리기가 남기고 간 것은 '깃발' 하나다 — 그 값으로 밖에서 일한다.
       인쇄도, 파일 닫기도, free 도 전부 여기서 한다. */
    puts("cleanup finished outside the loop");
    return 0;
}

/* POSIX sigaction — 표준 signal 이 남긴 빈틈을 메운다. */
#define _POSIX_C_SOURCE 200809L
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

static volatile sig_atomic_t hits;
static volatile sig_atomic_t last_code;
static volatile sig_atomic_t from_self;

/* SA_SIGINFO 를 주면 처리기가 세 인자를 받는다 — 누가 왜 보냈는지가 들어온다 */
static void on_signal(int sig, siginfo_t *info, void *ctx)
{
    (void)sig; (void)ctx;
    hits++;
    last_code = info->si_code;
    from_self = (info->si_pid == getpid());   /* 값 자체는 인쇄하지 않는다 */
}

static const char *code_name(int code)
{
    switch (code) {
    case SI_USER:   return "SI_USER (sent by a person, via kill/raise)";
    case SI_QUEUE:  return "SI_QUEUE(sigqueue)";
    case SI_TIMER:  return "SI_TIMER (a timer)";
    case SI_KERNEL: return "SI_KERNEL (sent by the kernel)";
    case -6:        return "SI_TKILL (raise from the same thread, Linux)";
    default:        return "some other implementation-defined value";
    }
}

int main(void)
{
    struct sigaction sa;
    memset(&sa, 0, sizeof sa);          /* 구조체는 통째로 0 으로 시작한다 */
    sa.sa_sigaction = on_signal;        /* SA_SIGINFO 를 쓰면 이쪽을 채운다 */
    sigemptyset(&sa.sa_mask);           /* 처리 중에 추가로 막을 신호들 */
    sigaddset(&sa.sa_mask, SIGUSR2);    /* USR1 처리 중에는 USR2 를 미룬다 */
    sa.sa_flags = SA_SIGINFO | SA_RESTART;  /* 정보 받기 + 시스템 호출 재시작 */

    struct sigaction old;
    if (sigaction(SIGUSR1, &sa, &old) != 0) return 1;

    printf("SIGUSR1 installed with sigaction. Previous handler: %s\n",
           old.sa_handler == SIG_DFL ? "SIG_DFL" : "there was one");

    /* 세 번 보낸다 — signal() 과 달리 처리기가 *남아 있다* */
    for (int i = 0; i < 3; i++) (void)raise(SIGUSR1);
    printf("after raising three times, handled = %d (the handler stays installed)\n", (int)hits);
    printf("  was the sender ourselves? %s\n", from_self ? "yes" : "no");
    printf("  si_code = %d → %s\n", (int)last_code, code_name((int)last_code));

    /* ── 신호를 잠시 막아 두기(블록) ─────────────────────────── */
    sigset_t block, prev;
    sigemptyset(&block);
    sigaddset(&block, SIGUSR1);
    if (sigprocmask(SIG_BLOCK, &block, &prev) != 0) return 1;

    int before = (int)hits;
    (void)raise(SIGUSR1);               /* 막혀 있으므로 대기 상태가 된다 */
    printf("\nraise while blocked: handled %d -> %d (not delivered yet)\n",
           before, (int)hits);

    sigset_t pending;
    sigpending(&pending);
    printf("  is it pending? %s\n",
           sigismember(&pending, SIGUSR1) ? "yes" : "no");

    sigprocmask(SIG_SETMASK, &prev, nullptr);   /* 풀면 그 자리에서 배달된다 */
    printf("  right after unblocking, handled = %d\n", (int)hits);

    /* ── 구조체 안을 들여다보기 ──────────────────────────────── */
    printf("\nsizeof(struct sigaction) = %zu bytes, sigset_t = %zu bytes\n",
           sizeof(struct sigaction), sizeof(sigset_t));
    printf("SA_RESTART=0x%x, SA_SIGINFO=0x%x, SA_NOCLDWAIT=0x%x\n",
           (unsigned)SA_RESTART, (unsigned)SA_SIGINFO, (unsigned)SA_NOCLDWAIT);
    return 0;
}