호타리
2025. 6. 13. 17:05
2025.06.13
00.signalprint.c
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
const char *binary[16] = {
[ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
[ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
[ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
[12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};
void print_byte(int byte){
// printf("%s%s", bit_rep[byte >> 4], bit_rep[byte & 0x0F]);
printf("%s", binary[byte & 0x0F]);
}
void print_sigset_t(sigset_t *set){
int i;
i = SIGRTMAX;
// i = 32;
do {
int x = 0;
i -= 4;
if (sigismember(set, i+1)) x |= 1;
if (sigismember(set, i+2)) x |= 2;
if (sigismember(set, i+3)) x |= 4;
if (sigismember(set, i+4)) x |= 8;
// printf("%x", x);
print_byte(x);
} while (i >= 4);
printf("\n");
}
int main(int argc, char **argv)
{
sigset_t set;
sigemptyset(&set);
/* add signals to set */
sigaddset(&set, SIGINT); //sig # 2
sigaddset(&set, SIGHUP); //sig # 1
sigaddset(&set, SIGALRM); //sig # 14
sigaddset(&set, SIGFPE); //sig # 8
sigaddset(&set, SIGABRT); //sig # 6
/* dump signals from set*/
print_sigset_t(&set);
}
01.signal.c
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
int repeat = 0;
void handler(int signo){
fprintf(stderr, "Signal handler triggered %d times (signum=%d)\n", repeat++, signo);
if(repeat >= 5)
signal(SIGINT, SIG_DFL);
if(signo == 15){
sleep(3);
exit(0);
}
}
int main(int argc, char *argv[]){
signal(SIGINT, handler);
signal(SIGQUIT, handler);
signal(SIGTERM, handler);
signal(SIGTSTP, handler);
while(1){
printf("signal interrupt test --- %d\n", repeat);
sleep(1);
}
return 0;
}
02.mypause.c
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
static void handler (int signo){
printf ("[%d] signal is caughted\n", signo);
}
int main (void){
signal(SIGRTMIN, handler);
signal(SIGRTMIN+1, handler);
for (;;){
for(int i=0; i<5; i++){
printf("I am running --- %d\n", i);
sleep(1);
}
printf("Now I am waiting for a signal --- ");
pause();
}
return 0;
}
01.mysignal_handler.c
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
static int cnt_int = 0;
static int cnt_quit = 0;
static int cnt_term = 0;
static int cnt_tstp = 0;
void handler_sigint(int signo){
fprintf(stderr, "Signal handler triggered %d times (signum=%d)\n", cnt_int++, signo);
if(cnt_int >= 5)
signal(SIGINT, SIG_DFL);
if(signo == 15){
sleep(3);
exit(0);
}
}
void handler_sigquit(int signo){
fprintf(stderr, "Signal handler triggered %d times (signum=%d)\n", cnt_quit++, signo);
if(cnt_quit >= 5)
signal(SIGQUIT, SIG_DFL);
if(signo == 15){
sleep(3);
exit(0);
}
}
void handler_sigterm(int signo) {
cnt_term++;
fprintf(stderr, "[SIGTERM] count=%d, signo=%d\n", cnt_term, signo);
if (cnt_term >= 5) {
signal(SIGTERM, SIG_DFL);
}
}
void handler_sigtstp(int signo){
fprintf(stderr, "Signal handler triggered %d times (signum=%d)\n", cnt_tstp++, signo);
if(cnt_tstp >= 5)
signal(SIGTSTP, SIG_DFL);
if(signo == 15){
sleep(3);
exit(0);
}
}
int main(int argc, char *argv[]){
signal(SIGINT, handler_sigint);
signal(SIGQUIT, handler_sigquit);
signal(SIGTERM, handler_sigterm);
signal(SIGTSTP, handler_sigtstp);
while(1){
printf("signal interrupt test --- INT:%d, QUIT:%d, TERM:%d, TSTP:%d\n", cnt_int, cnt_quit, cnt_term, cnt_tstp);
sleep(1);
}
return 0;
}
ctrl+c : int
ctrl+\ : tstp
ctrl+z : quit
kill : tstp
03.mykill.c
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
int main(int argc, char *argv[]){
#if 1
if(argc < 3){
fprintf(stderr, "Usage: %s <pid_#> <sig_#>\n", argv[0]);
exit(1);
}
if(kill(atoi(argv[1]), atoi(argv[2])) == -1){
if(errno == EINVAL){
printf("Invalid signal\n");
}else if(errno == EPERM){
printf("No Permission\n");
}else if(errno == ESRCH){
printf("No such process\n");
}
}
#else
if(argc < 2){
fprintf(stderr, "Usage: %s <pid_#>\n", argv[0]);
exit(1);
}
for (int i=34; i<64; i++){
kill(atoi(argv[1]), i);
sleep(3);
}
#endif
return 0;
}
04.myraise.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
void handler(int signo){
printf("Received Signal no - %d\n", signo);
}
int main(int argc, char *argv[]){
int a,b;
for(int i=1; i<64; i++){
if(signal(i, handler) == SIG_ERR){
fprintf (stderr, "Cannot handle signal=%d\n", i);
}
}
for(int i=0; i<64; i++){
if(i!=9 && i!=32 && i!=33){
// kill(getpid(), i);
raise(i);
sleep(1);
}
}
return 0;
}
04.myraise_kill.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
int count = 0;
void handler(int signo){
printf("Received Signal no - %d\n", signo);
if(signo == 34){
count++;
fprintf (stderr, "signo34, count up, count : %d\n", count);
}else if(signo == 35){
count--;
fprintf (stderr, "signo35, count down, count : %d\n", count);
}
}
void handler34(int signo){
count++;
fprintf (stderr, "signo34, count up, count : %d\n", count);
}
void handler35(int signo){
count--;
fprintf (stderr, "signo35, count down, count : %d\n", count);
}
int main(int argc, char *argv[]){
int a,b;
printf("pid : %d\n", getpid());
signal(34, handler34);
signal(35, handler35);
while(1){
sleep(1);
}
return 0;
}
05.setprocmask.c
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include "signalprint.h"
void handler(int signo){
printf ("[%d] signal is caughted\n", signo);
}
int main(void) {
sigset_t set1, set2, set3, set4, oldset;
signal(SIGQUIT, handler); // ctrl + \
sleep(2);
sigemptyset(&set1);
sigaddset(&set1, 2);
printf("signals in set1 are blocked\n");
printf("set1 : ");
print_sigset_t(&set1);
sigprocmask(SIG_BLOCK, &set1, &oldset);
printf("oldset: ");
print_sigset_t(&oldset);
sleep(5);
sigemptyset(&set2);
sigaddset(&set2, SIGQUIT);
printf("\nSignals in set2 are blocked\n");
printf("set2 : ");
print_sigset_t(&set2);
sigprocmask(SIG_BLOCK, &set2, &oldset);
printf("oldset: ");
print_sigset_t(&oldset);
sleep(5);
sigemptyset(&set4);
sigaddset(&set4, SIGRTMIN);
printf("\nSignals in set4 are now blocked\n");
printf("set4 : ");
print_sigset_t(&set4);
sigprocmask(SIG_BLOCK, &set4, &oldset);
printf("oldset: ");
print_sigset_t(&oldset);
sleep(5);
sigfillset(&set3);
printf("\nThe set of blocked signal is replaced by set3\n");
printf("set3 : ");
print_sigset_t(&set3);
sigprocmask(SIG_SETMASK, &set3, &oldset);
printf("oldset : ");
print_sigset_t(&oldset);
sleep(5);
printf("\nSignals in oldset are now unblocked\n");
sigprocmask(SIG_UNBLOCK, &oldset, NULL);
for(int i=0; ; i++){
printf("Hello Signal --- %d\n", i);
sleep(1);
}
return 0;
}
signalprint.h
void print_sigset_t(sigset_t*set);
00.signalprint.c
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
const char *binary[16] = {
[ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
[ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
[ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
[12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};
void print_byte(int byte){
// printf("%s%s", bit_rep[byte >> 4], bit_rep[byte & 0x0F]);
printf("%s", binary[byte & 0x0F]);
}
void print_sigset_t(sigset_t *set){
int i;
i = SIGRTMAX;
// i = 32;
do {
int x = 0;
i -= 4;
if (sigismember(set, i+1)) x |= 1;
if (sigismember(set, i+2)) x |= 2;
if (sigismember(set, i+3)) x |= 4;
if (sigismember(set, i+4)) x |= 8;
// printf("%x", x);
print_byte(x);
} while (i >= 4);
printf("\n");
}
/*
int main(int argc, char **argv)
{
sigset_t set;
sigemptyset(&set);
/* add signals to set
sigaddset(&set, SIGINT); //sig # 2
sigaddset(&set, SIGHUP); //sig # 1
sigaddset(&set, SIGALRM); //sig # 14
sigaddset(&set, SIGFPE); //sig # 8
sigaddset(&set, SIGABRT); //sig # 6
/* dump signals from set
print_sigset_t(&set);
}
*/
06.mysigsuspend.c
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include "signalprint.h"
static void handler(int signo) {
printf ("[%d] signal is caughted\n", signo);
}
int main() {
sigset_t set1,set2;
signal(SIGINT, handler);
signal(SIGRTMAX-1, handler);
sigemptyset(&set1);
sigaddset(&set1,SIGINT);
sigaddset(&set1,SIGRTMAX-1);
sigfillset(&set2);
sigdelset(&set2, SIGINT);
sigdelset(&set2, SIGRTMAX-1);
sigprocmask(SIG_BLOCK,&set1,NULL);
print_sigset_t(&set1);
print_sigset_t(&set2);
for(int i=0; i<5; i++){
printf("Critical Region 1 is running --- %d\n", i);
sleep(1);
}
#if 1
printf("Waiting for a signal ----------------- \n");
sigsuspend(&set2);
#else
sigprocmask(SIG_SETMASK, &set2, NULL);
printf("Waiting for a signal ----------------- \n");
pause();
#endif
for(int i=0; i<5; i++){
printf("Critical Region 2 is running --- %d\n", i);
sleep(1);
}
exit(0);
}
07.mysigaction.c
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include "signalprint.h"
void handler(int sig){ㅐ
sigset_t sigset;
sigprocmask(SIG_SETMASK, NULL, &sigset);
printf("blocked signal set : ");
print_sigset_t(&sigset);
for(int i=1; i<=3; i++) {
printf("handler_%d!!\n", i);
sleep(1);
}
}
int main(void){
struct sigaction act, oldact;
act.sa_handler = handler;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask,SIGQUIT);
// act.sa_flags=SA_NODEFER;
act.sa_flags=SA_RESTART;
// act.sa_flags=SA_RESETHAND;
sigaction(SIGINT, &act, &oldact);
for(int i=1; ; i++){
printf("signal test --- %d\n", i);
sleep(2);
}
return 0;
}
08.mysigalarm.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
void alarm_handler(int signo){
printf("Time over, try again later---\n");
exit(0);
}
int main(int argc, char *argv[]){
char buf[512];
char *passwd = "hello";
struct sigaction act;
if(argc <2){
fprintf(stderr, "Usage: %s <timelimit>\n", argv[0]);
exit(1);
}
act.sa_handler = alarm_handler;
sigaction(SIGALRM, &act, NULL);
alarm(atoi(argv[1]));
while(1){
printf("Input password: ");
scanf("%s", buf);
if(!strcmp(buf, passwd)){
printf("Success\n");
break;
}else{
printf("Fail\n");
}
}
printf("Main function -----\n");
return 0;
}
10.mysigpending.c
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include "signalprint.h"
static void handler(int signo) {
printf("Signal #(%d) is caught\n", signo);
}
int main( void){
sigset_t sigset, oldset, pendingset;
for(int i=1; i<=64; i++){
signal(i, handler);
}
sigfillset(&sigset);
sigprocmask(SIG_SETMASK, &sigset, &oldset);
print_sigset_t(&oldset);
int i=0;
while(1){
printf( "I am running --- %d\n", i++);
sleep(1);
if (sigpending(&pendingset) == 0){
print_sigset_t(&pendingset);
if (sigismember(&pendingset, SIGINT)){
printf( "SIGINT was pended --- end of loop.\n");
break;
}
if(sigismember(&pendingset, SIGTSTP)){
printf( "SIGTSTP was pended --- end of loop.\n");
break;
}
}
}
sigprocmask(SIG_SETMASK, &oldset, NULL);
sleep(3);
return 0;
}
07.mysigaction_intquit.c
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include "signalprint.h" // print_sigset_t()
void handler(int sig) {
sigset_t sigset;
// 현재 블록된 시그널 집합을 조회
sigprocmask(SIG_SETMASK, NULL, &sigset);
printf("blocked signal set: ");
print_sigset_t(&sigset);
for (int i = 1; i <= 3; i++) {
printf("handler_%d for SIGINT\n", i);
sleep(1);
}
}
int main(void) {
struct sigaction act;
sigset_t block_set;
// 1) SIGINT 에만 handler 등록
sigemptyset(&act.sa_mask); // handler 중 추가 차단 안 함
act.sa_handler = handler;
act.sa_flags = SA_RESTART; // 시스템 호출 자동 재시작
if (sigaction(SIGINT, &act, NULL) < 0) {
perror("sigaction(SIGINT)");
exit(1);
}
// 2) SIGQUIT 은 아무 설정도 하지 않아 기본 동작 유지
// 3) 그 외 모든 시그널을 block_set 에 추가
sigfillset(&block_set); // 집합을 모두 1로
sigdelset(&block_set, SIGINT); // SIGINT 만 언블록
sigdelset(&block_set, SIGQUIT); // SIGQUIT 만 언블록
// 4) 프로세스 시그널 마스크로 적용 → 언블록된 시그널만 전달됨
if (sigprocmask(SIG_SETMASK, &block_set, NULL) < 0) {
perror("sigprocmask");
exit(1);
}
// 5) 메인 루프
for (int i = 1; ; i++) {
printf("signal test --- %d\n", i);
sleep(2);
}
return 0;
}