UNIX/LINUX编程学习之信号2

转自：
http://shihaiyang.iteye.com/blog/443738

信号捕捉 
示列程序实现对SIGINT的捕捉 

C代码  

1. #include <stdlib.h>  
2. #include <stdio.h>  
3. #include <signal.h>  
4. int catch(int sig);  
5. int main(void)  
6. {  
7.         signal(SIGINT,catch);  /* 将SIGINT 信号与catch函数关联 */  
8.          printf("xixi\n");  
9.          sleep(10);  
10.          printf("end\n");  
11.          return;  
12. }  
13. int catch(int sig)  
14. {  
15.          printf("Catch succeed!\n");  
16.          return 1;  
17. }  

执行过程： 

Shell代码  

1. pro_1.c: In function `main':  
2. pro_1.c:7: warning: passing arg 2 of `signal' from incompatible pointer type  
3. /home/l/g/tomotoboy/signal >pro_1  
4. xixi  
5. ^CCatch succeed!  
6. end  

信号与系统调用的关系 
当一个进程正在执行一个系统调用时，如果向该进程发送一个信号，那么对于大多数系统调用来说，这个信号在系统调用完成之前将不起作用，因为这些系统调用不能被信号打断。但是有少数几个系统调用能被信号打断，例如：wait(),pause()以及对慢速设备（终端、打印机等）的 read()、write()、open()等。如果一个系统调用被打断，它就返回-1，并将errno设为 EINTR。可以用下列代码来处理这种情况： 

C代码  

1. if (wirte(tfd,buf,SIZE)<0) {  
2.   if (errno==EINTR) {  
3.   warn(“ Write interrupted.” );  
4.   …  
5.   …  
6.   }  
7. }  

信号的复位 
在 Linux 中，当一个信号的信号处理函数执行时，如果进程又接收到了该信号，该信号会自动被储存而不会中断信号处理函数的执行，直到信号处理函数执行完毕再重新调用相应的处理函数。下面的程序演示了这一点： 

Shell代码  

1. #include <signal.h>  
2. int interrupt()  
3. {  
4.      printf(" Interrupt called\n" );  
5.      sleep(3);  
6.      printf(" Interrupt Func Ended.\n" );  
7. }  
8. main()  
9. {  
10.      signal(SIGINT,interrupt);  
11.      printf(" Interrupt set for SIGINT\n" );  
12.      sleep(10);  
13.      printf(" Program NORMAL ended.\n" );  
14.      return;  
15. }  

执行过程： 

Shell代码  

1. /home/l/g/tomotoboy/signal >pro_2  
2. Interrupt set for SIGINT  
3. ^C Interrupt called  
4. ^C  
5. /home/l/g/tomotoboy/signal >pro_2  
6. Interrupt set for SIGINT  
7. ^C Interrupt called  
8. Interrupt Func Ended.Program NORMAL ended.  

问题：当我第二次按下Ctrl+C时，程序直接终止，现在还在找原因 
但是如果在信号处理函数执行时进程收到了其它类型的信号，该函数的执行就会被中断： 

C代码  

1. #include <signal.h>  
2. int interrupt()  
3. {  
4. printf(" Interrupt called\n" );  
5. sleep(3);  
6. printf(" Interrupt Func Ended.\n" );  
7. }  
8. int catchquit()  
9. {  
10. printf(" Quit called\n" );  
11. sleep(3);  
12. printf(" Quit ended.\n" );  
13. }  
14. main()  
15. {  
16.    signal(SIGINT,interrupt);  
17.    signal(SIGQUIT,catchquit);  
18.     printf(" Interrupt set for SIGINT\n" );  
19.     sleep(10);  
20.     printf(" Program NORMAL ended.\n" );  
21.     return;  
22. }  

执行这个程序的结果如下： 

Shell代码  

1. /home/l/g/tomotoboy/signal >gcc pro_3.c -o pro_3  
2. pro_3.c: In function `main':  
3. pro_3.c:16: warning: passing arg 2 of `signal' from incompatible pointer type  
4. pro_3.c:17: warning: passing arg 2 of `signal' from incompatible pointer type  
5. /home/l/g/tomotoboy/signal >pro_3  
6.  Interrupt set for SIGINT  
7. ^C Interrupt called  
8. ^\ Quit called  
9.  Quit ended.  
10.  Interrupt Func Ended.  
11.  Program NORMAL ended.  

还要注意的是，在 Linux 系统中同种信号是不能积累的。而且如果两个信号同时产生，系统并不保证进程接收它们的次序。以上的两个缺点影响了信号作为进程通信手段的可靠性，因为一个进程不能保证它发出的信号不被丢失。当某个信号未被处理的时候，如果对该信号执行 signal调用，那么该信号将被注销。 

在进程间发送信号 
一个进程通过对 signal()的调用来处理其它进程发送来的信号。同时，一个进程也可以向其它的进程发送信号。这一操作是由系统调用 kill()来完成的。 kill()在 linux 系统库 signal.h中的函数声明如下： 

C代码  

1. int kill(pid_t pid, int sig);  

参数 pid 指定了信号发送的对象进程：它可以是某个进程的进程标识符(pid)，也可以是以下的值： 

• 如果 pid 为零，则信号被发送到当前进程所在的进程组的所有进程。
• 如果 pid 为-1，则信号按进程标识符从高到低的顺序发送给全部的进程（这个过程受到当前进程本身权限的限制)；
• 如果 pid 小于-1,则信号被发送给标识符为 pid 绝对值的进程组里的所有进程。
• 参数 sig 指定发送的信号类型。它可以是任何有效的信号。

需要说明的是，一个进程并不是向任何进程均能发送信号的，这里有一个限制，就是普通用户的进程只能向具有与其相同的用户标识符的进程发送信号。也就是说，一个用户的进程不能向另一个用户的进程发送信号。只有 root 用户的进程能够给任何线程发送信号。 

由于调用 kill()的进程需要直到信号发往的进程的标识符，所以这种信号的发送通常只在关系密切的进程之间进行，比如父子进程之间。 

C代码  

1. #include <signal.h>  
2. int ntimes=0;  
3. main(){  
4.   
5. int pid,ppid;  
6. int p_action(),c_action();  
7. signal(SIGUSR1,p_action);  
8. switch(pid=fork()){  
9. case -1:  
10.         perror("sychro");  
11.         exit(1);  
12. case 0:  
13.         signal(SIGUSR1,c_action);  
14.                 ppid=getppid();  
15.         for(;;){  
16.                 sleep(1);  
17.                 kill(ppid,SIGUSR1);  
18.                 pause();  
19.         }  
20.         break;  
21.   
22. default:  
23.         for(;;){  
24.                 pause();  
25.                 sleep(1);  
26.                 kill(pid,SIGUSR1);  
27.   
28.         }  
29. }  
30. }  
31. p_action()  
32. {  
33.         printf("Patent caught signal #%d\n",++ntimes);  
34. }  
35. c_action()  
36. {  
37.         printf("Child caught signal #%d\n",++ntimes);  
38. }  

执行过程如下： 

Shell代码  

1. /home/l/g/tomotoboy/signal >gcc pro_4.c -o pro_4  
2. pro_4.c: In function `main':  
3. pro_4.c:6: warning: passing arg 2 of `signal' from incompatible pointer type  
4. pro_4.c:12: warning: passing arg 2 of `signal' from incompatible pointer type  
5. /home/l/g/tomotoboy/signal >pro_4  
6. Patent caught signal #1  
7. Child caught signal #1  
8. User Signal 1  

问题：本来按照程序的意图父、子应该循环交替执行，然而各自却只执行了一次就结束了 
kill命令用于向一个运行进程发送信号，它发送的信号默认为 SIGTERM，但是也可以指定为其它信号。我们可以直接用信号的号码来指定 kill 命令所发送信号之类型，也可以用符号名指定。比如可以用下面的命令来完成向进程标识符为 1234 的进程发送SIGINT 信号： 

Shell代码  

1. kill – s SIGINT 1234  

系统调用 alarm()和 pause() 
1．系统调用 alarm() 
alarm()是一个简单而有用的系统调用，它可以建立一个进程的报警时钟，在时钟定时器到时的时候，用信号向程序报告。alarm()系统调用在 Linux 系统函数库 unistd.h中的函数 
声明如下： 

C代码  

1. unsigned int alarm(unsigned int seconds);  

下面这个程序使用上述方法来强制用户作出回答。在其中包括一个 quickreply()函数，它有一个参数 prompt，它是一个指向提示字符串的指针。quickreply 的返回值也是一个指针。它指向含有输入行信息的字符串。这个例行程序在试作五次之后，如果仍未得到输入信息，就返回一个 null 指针。每当quickreply 要提醒用户时，它就向终端发送 ASCII 码 007，这会使终端响铃。 

C代码  

1. #include <stdio.h>  
2. #include <signal.h>  
3. #define TIMEOUT 5  
4. #define MAXTRIES 5  
5. #define LINESIZE 100  
6. #define BELL '\007'  
7. #define TRUE 1  
8. #define FALSE 0  
9. static int time_out;/*判断超时是否已经发生的标志 */  
10. static char inputline[LINESIZE];  
11. char* quickreply (char* prompt);  
12. main()  
13. {  
14.     printf("%s\n",quickreply("Input"));  
15. }  
16. char* quickreply (char* prompt)  
17. {  
18.     int (*was)(),catch(),ntries;  
19.     char* answer;  
20.     /*设定捕捉SIGALRM 的的关联并保存原有关联*/  
21.     was=signal(SIGALRM,catch);  
22.     for (ntries=0;ntries<MAXTRIES;ntries++)  
23.     {  
24.         time_out=FALSE;  
25.         printf("\n%s>",prompt);  
26.         /* 设定定时器 */  
27.         alarm(TIMEOUT);  
28.         /* 获取输入 */  
29.         answer=gets(inputline);  
30.         /* 关闭定时器 */  
31.         alarm(0);  
32.         if (!time_out)  
33.             break;  
34.     }  
35.     /*恢复原有的SIGALRM 关联 */  
36.     signal(SIGALRM,was);  
37.     return (time_out?((char*) 0):answer);  
38. }  
39. /*SIGALRM 信号处理函数*/  
40. catch()  
41. {  
42.     /*设定超时标志*/  
43.     time_out=TRUE;  
44.     /* 响铃警告 */  
45.     putchar(BELL);  
46. }  

执行结果： 

Shell代码  

1. /home/l/g/tomotoboy/signal >gcc pro_5.c -o pro_5  
2. pro_5.c: In function `quickreply':  
3. pro_5.c:20: warning: passing arg 2 of `signal' from incompatible pointer type  
4. pro_5.c:20: warning: assignment from incompatible pointer type  
5. pro_5.c:31: warning: passing arg 2 of `signal' from incompatible pointer type  
6. /home/l/g/tomotoboy/signal >pro_5  
7.   
8. Input>  
9. Input>Alarm Clock  
10. /home/l/g/tomotoboy/signal >pro_5  
11.   
12. Input>hello  
13. hello  
14. /home/l/g/tomotoboy/signal >pro_5  
15.   
16. Input>  
17. Input>Alarm Clock  
18. /home/l/g/tomotoboy/signal >  

不知道怎么回事，今天这几个程序都没有循环起来，信号也只是发了一次，原因查找当中…… 

2．系统调用 pause() 
系统调用 pause()能使调用进程暂停执行，直至接收到某种信号为止。pause()在 Linux系统函数库 unistd.h中的函数声明如下： 
int pause(void); 
该调用没有任何的参数。它的返回始终是 -1 ，此时 errno 被设置为ERESTARTNOHAND。 


参考资料： 
《linux网络编程》李卓恒等译