Signal

#include <sys/types.h>
#include <signal.h>
 
int kill(pid_t pid, int sig);

#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
 
int main() {
    printf("Before SIGCONT Signal to parent.\n");
    kill(getppid(), SIGCONT); // 부모 프로세스에 SIGCONT 시그널을 보냄
 
    printf("Before SIGQUIT Signal to me.\n");
    kill(getpid(), SIGQUIT); // 현재 프로세스(자신)에 SIGQUIT 시그널을 보냄
    printf("After SIGQUIT Signal\n");
 
    return 0;
}

int raise(int sig);

void abort(void);

#include <signal.h>
 
sighandler_t signal(int signum, sighandler_t handler);

#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
 
void sig_handler(int signo) {
    printf("Signal Handler signum: %d\n", signo);
    psignal(signo, "Received Signal");
}
 
int main() {
    void (*hand)(int);
 
    // SIGINT 시그널의 시그널 핸들러를 지정
    hand = signal(SIGINT, sig_handler);
    if(hand == SIG_ERR) {
        perror("signal");
        exit(1);
    }
 
    printf("Wait 1st Ctrl+C... : SIGINT\n");
    pause();
 
    printf("Wait 2nd Ctrl+C... : SIGINT\n");
    pause();
 
    printf("After 2nd Signal Handler\n");
    return 0;
}

typedef struct {
    unsigned long _val[_NSIG_WORDS];
} sigset_t;

int sigemptyset(sigset_t *set);     // 시그널 집합을 빈 집합으로 만듦
int sigfillset(sigset_t *set);      // 모든 시그널을 포함하는 집합으로 만듦
int sigaddset(sigset_t *set, int signum);   // 시그널 집합에 시그널 추가
int sigdelset(sigset_t *set, int signum);   // 시그널 집합에서 시그널 삭제
int sigismember(const sigset_t *set, int signum); // 시그널이 집합에 있는지 확인

#include <signal.h>
#include <stdio.h>
 
int main() {
    sigset_t st;
 
    // 시그널 집합을 모두 비운다
    sigemptyset(&st);
 
    // 시그널 집합에 SIGINT와 SIGQUIT 시그널을 추가한다
    sigaddset(&st, SIGINT);
    sigaddset(&st, SIGQUIT);
 
    if (sigismember(&st, SIGINT)) {
        printf("SIGINT has been set.\n");
    }
 
    // 시그널 집합에 설정된 값을 16진수로 출력
    printf("** Bit Pattern: %lx\n", st.__val[0]);
 
    return 0;
}

struct sigaction {
    int sa_flags;
    union {
        void (*sa_handler)();
        void (*sa_sigaction)(int, siginfo_t *, void *);
    } _funcptr;
    sigset_t sa_mask;
};

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
 
void sig_handler(int signo) {
    psignal(signo, "Received Signal:");
    sleep(5);
    printf("In Signal Handler, After Sleep\n");
}
 
int main() {
    struct sigaction act;
 
    sigemptyset(&act.sa_mask);
    // 시그널 핸들러가 동작하는 중에 SIGQUIT 시그널을 블로킹
    sigaddset(&act.sa_mask, SIGQUIT);
 
    act.sa_flags = 0;
    act.sa_handler = sig_handler;
 
    // SIGINT 시그널을 받을 경우 시그널 핸들러가 동작하도록 설정
    if(sigaction(SIGINT, &act, (struct sigaction *)NULL) < 0) {
        perror("sigaction");
        exit(1);
    }
 
    fprintf(stderr, "Input SIGINT: ");
    pause(); // 시그널이 올 때까지 대기
    fprintf(stderr, "\nAfter Signal Handler\n");
 
    return 0;
}

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

int main(int argc, char *argv[]) {
    // 시그널 핸들러 등록
    signal(SIGINT, handler);
 
    // SIGINT를 블로킹할 집합 준비
    sigset_t block_set, old_set;
    sigemptyset(&block_set);
    sigaddset(&block_set, SIGINT);
 
    // SIGINT 블로킹 시작 → 시그널 핸들러 재진입 방지
    sigprocmask(SIG_BLOCK, &block_set, &old_set);
 
    // 이 부분은 안전함. 시그널 핸들러와 동시에 실행되지 않음
    prepend(new_listnode());
 
    // 다시 SIGINT 허용
    sigprocmask(SIG_SETMASK, &old_set, NULL);
 
    return 0;
}

int sigsetjmp(sigjmp_buf env, int savemask);

void siglongjmp(sigjmp_buf env, int val);

#include <stdio.h>
#include <signal.h>
#include <setjmp.h>
#include <unistd.h>
 
// 전역 점프 버퍼 선언
static sigjmp_buf buf;
 
// 시그널 핸들러 함수
void handler(int sig) {
    // 저장된 지점으로 복귀하면서 sigsetjmp의 반환값을 1로 설정
    siglongjmp(buf, 1);
}
 
int main() {
    // 처음 호출 시에는 0을 반환하고, siglongjmp로 돌아오면 1을 반환함
    if (!sigsetjmp(buf, 1)) {
        // 초기 실행 시 → 핸들러 등록
        signal(SIGINT, handler);
        puts("starting");
    } else {
        // Ctrl+C를 눌러 siglongjmp로 되돌아온 경우
        puts("restarting");
    }
 
    // 무한 루프: 1초마다 "processing..." 출력
    while (1) {
        sleep(1);
        puts("processing...");
    }
 
    return 0;
}