1     /*
 2      * 在信号处理函数中调用longjmp的错误情况
 3      */
 4     #include <errno.h>
 5     #include <setjmp.h>
 6     #include <signal.h>
 7     #include <string.h>
 8     #include <stdlib.h>
 9     #include <stdarg.h>
10     #include <stdio.h>
11     #define BUFSIZE 512
12     jmp_buf env;
13
14     void err_exit(char *fmt,...);
15     int err_dump(char *fmt,...);
16     int err_ret(char *fmt,...);
17
18     void alrm_handler(int signo)
19     {
20         printf("Get the SIG_ALRM\n");
21         longjmp(env,2);
22     }
23     void send_signal()
24     {
25         int count = 0;
26
27         if(SIG_ERR == signal(SIGALRM,alrm_handler))
28             err_exit("[signal]: ");
29
30         alarm(1);
31         if(2 != setjmp(env)) {
32             pause();
33         } else {
34             count++;
35         }
36
37         /* 使这个信号只能发送一次 */
38         if(1 == count) {
39             alarm(1);
40             pause();
41         }
42     }
43
44     int main(int argc,char *argv[])
45     {
46         send_signal();
47         return 0;
48     }

 1     /*
 2      * 信号处理函数中调用longjmp函数的修正版本1
 3      */
 4
 5     #include <errno.h>
 6     #include <setjmp.h>
 7     #include <signal.h>
 8     #include <string.h>
 9     #include <stdlib.h>
10     #include <stdarg.h>
11     #include <stdio.h>
12
13     #define BUFSIZE 512
14
15     jmp_buf env;
16
17     void err_exit(char *fmt,...);
18     int err_dump(char *fmt,...);
19     int err_ret(char *fmt,...);
20
21     void alrm_handler(int signo)
22     {
23         printf("Get the SIG_ALRM\n");
24         longjmp(env,2);
25     }
26     void send_signal()
27     {
28         sigset_t sigset,oldset;
29         int count = 0;
30
31         if(SIG_ERR == signal(SIGALRM,alrm_handler))
32             err_exit("[signal]: ");
33
34         alarm(1);
35         if(2 != setjmp(env)) {
36             pause();
37         } else {
38             count++;
39         }
40
41         /* 检测SIGALRM信号是否被阻塞 */
42         if(-1 == sigprocmask(0,NULL,&sigset))
43             err_exit("[sigprocmask]");
44         if(sigismember(&sigset,SIGALRM)) {
45             printf("Sigalrm has been blocked\n");
46             /* 将SIGALRM信号取消阻塞 */
47             if(-1 == sigdelset(&sigset,SIGALRM))
48                 err_exit("[sigdelset]");
49             if(-1 == sigprocmask(SIG_SETMASK,&sigset,&oldset))
50                 err_exit("[sigprocmask]");
51         }
52
53         /* 使这个信号只能发送一次 */
54         if(1 == count) {
55             alarm(1);
56             pause();
57         }
58     }
59
60     int main(int argc,char *argv[])
61     {
62         send_signal();
63         return 0;
64     }

 1     /*
 2      * 在信号处理函数中调用longjmp修正版本2
 3      *
 4      * 将jmp系列的函数改成sigjmp系列的
 5      */
 6
 7     #include <errno.h>
 8     #include <setjmp.h>
 9     #include <signal.h>
10     #include <string.h>
11     #include <stdlib.h>
12     #include <stdarg.h>
13     #include <stdio.h>
14
15     #define BUFSIZE 512
16
17     sigjmp_buf env;
18
19     void err_exit(char *fmt,...);
20     int err_dump(char *fmt,...);
21     int err_ret(char *fmt,...);
22
23     void alrm_handler(int signo)
24     {
25         printf("Get the SIG_ALRM\n");
26         siglongjmp(env,2);
27     }
28     void send_signal()
29     {
30         int count = 0;
31         if(SIG_ERR == signal(SIGALRM,alrm_handler))
32             err_exit("[signal]: ");
33
34         alarm(1);
35         if(2 != sigsetjmp(env,1)) {
36             pause();
37         } else {
38             count++;
39         }
40
41         if(1 == count) {
42             alarm(1);
43             pause();
44         }
45     }
46
47     int main(int argc,char *argv[])
48     {
49         send_signal();
50         return 0;
51     }