20135223何伟钦—信息安全系统设计基础第十二周学习总结
一、学习目标
1.掌握进程控制
2.掌握信号处理的方法
3.掌握管道和fifo进行进程间通信的方法
二、学习资源
编译、运行、阅读、理解process.tar.gz压缩包中的代码
三、编译、运行、阅读、理解代码
（1）exec1
execvp函数
表头文件：
#include
定义函数：
int execvp(const char file ,char const argv []);
execvp()会从PATH 环境变量所指的目录中查找符合参数file 的文件名，找到后便执行该文件，然后将第二个参数argv传给该欲执行的文件。
如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。
代码如下：
#include <stdio.h> #include <unistd.h> int main() { char *arglist[3]; arglist[0] = "ls"; arglist[1] = "-l"; arglist[2] = 0 ;//NULL printf("* * * About to exec ls -l\n"); execvp( "ls" , arglist ); printf("* * * ls is done. bye"); return 0; }
运行结果如下：
可以看到，exevp函数调用成功没有返回，所以没有打印出“* * * ls is done. bye”这句话。
exec2
它与exec1的区别就在于exevp函数的第一个参数，exec1传的是ls，exec2直接用的arglist[0]，不过由定义可得这两个等价，所以运行结果是相同的。
exec3
代码如下：
#include <stdio.h> #include <unistd.h> int main() { char *arglist[3]; char*myenv[3]; myenv[0] = "PATH=:/bin:"; myenv[1] = NULL; arglist[0] = "ls"; arglist[1] = "-l"; arglist[2] = 0 ; printf("* * * About to exec ls -l\n"); execlp("ls", "ls", "-l", NULL); printf("* * * ls is done. bye\n"); }这个代码里使用了execlp函数，用法如下：
头文件：
#include
定义函数：
int execlp(const char * file,const char * arg,....);
函数说明：
execlp()会从PATH 环境变量所指的目录中查找符合参数file的文件名，找到后便执行该文件，然后将第二个以后的参数当做该文件的argv[0]、argv[1]……，最后一个参数必须用空指针(NULL)作结束。如果用常数0来表示一个空指针，则必须将它强制转换为一个字符指针，否则将它解释为整形参数，如果一个整形数的长度与char * 的长度不同，那么exec函数的实际参数就将出错。如果函数调用成功,进程自己的执行代码就会变成加载程序的代码,execlp()后边的代码也就不会执行了.
返回值：
如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno 中。
也就是说，这个代码指定了环境变量，然后依然执行了ls -l指令，成功后没有返回，所以最后一句话不会输出。运行结果同exec1.
forkdemo1
代码如下：
#include <stdio.h> #include<sys/types.h> #include<unistd.h> int main() { int ret_from_fork, mypid; mypid = getpid(); printf("Before: my pid is %d\n", mypid); ret_from_fork = fork(); sleep(1); printf("After: my pid is %d, fork() said %d\n", getpid(), ret_from_fork); return 0; }代码解释：
这个代码先是打印进程pid，然后调用fork函数生成子进程，休眠一秒后再次打印进程id，这时父进程打印子进程pid，子进程返回0.
运行结果如下：
forkdemo2
代码如下：
#include <stdio.h> #include <unistd.h> int main() { printf("before:my pid is %d\n", getpid() ); fork(); fork(); printf("aftre:my pid is %d\n", getpid() ); return 0; }这个代码调用两次fork，一共产生四个子进程，所以会打印四个aftre输出。
结果如图：
forkdemo3
代码如下：
#include <stdio.h> #include <stdlib.h> #include <unistd.h> int main() { int fork_rv; printf("Before: my pid is %d\n", getpid()); fork_rv = fork(); /* create new process */ if ( fork_rv == -1 ) /* check for error */ perror("fork"); else if ( fork_rv == 0 ){ printf("I am the child. my pid=%d\n", getpid()); exit(0); } else{ printf("I am the parent. my child is %d\n", fork_rv); exit(0); } return 0; }fork产生子进程，父进程返回子进程pid，不为0，所以输出父进程的那句话，子进程返回0，所以会输出子进程那句话。
结果如下：
forkdemo4
代码：
#include <stdio.h> #include <stdlib.h> #include <unistd.h> int main() { int fork_rv; printf("Before: my pid is %d\n", getpid()); fork_rv = fork(); /* create new process */ if ( fork_rv == -1 ) /* check for error */ perror("fork"); else if ( fork_rv == 0 ){ printf("I am the child. my pid=%d\n", getpid()); printf("parent pid= %d, my pid=%d\n", getppid(), getpid()); exit(0); } else{ printf("I am the parent. my child is %d\n", fork_rv); sleep(10); exit(0); } return 0; }先打印进程pid，然后fork创建子进程，父进程返回子进程pid，所以输出parent一句，休眠十秒；子进程返回0，所以输出child与之后一句。
运行结果如下：
forkgdb
代码如下：
#include <stdio.h> #include <stdlib.h> #include <unistd.h> int gi=0; int main() { int li=0; static int si=0; int i=0; pid_t pid = fork(); if(pid == -1){ exit(-1); } else if(pid == 0){ for(i=0; i<5; i++){ printf("child li:%d\n", li++); sleep(1); printf("child gi:%d\n", gi++); printf("child si:%d\n", si++); } exit(0); } else{ for(i=0; i<5; i++){ printf("parent li:%d\n", li++); printf("parent gi:%d\n", gi++); sleep(1); printf("parent si:%d\n", si++); } exit(0); } return 0; }显示结果如下：
这个的主要区别是在，父进程打印是先打印两句，然后休眠一秒，然后打印一句，子进程先打印一句，然后休眠一秒，然后打印两句。并且这两个线程是并发的，所以可以看到在一个线程休眠的那一秒，另一个线程在执行，并且线程之间相互独立互不干扰。
psh1
代码：
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #define MAXARGS 20 #define ARGLEN 100 int execute( char *arglist[] ) { execvp(arglist[0], arglist); perror("execvp failed"); exit(1); } char * makestring( char *buf ) { char *cp; buf[strlen(buf)-1] = '\0'; cp = malloc( strlen(buf)+1 ); if ( cp == NULL ){ fprintf(stderr,"no memory\n"); exit(1); } strcpy(cp, buf); return cp; } int main() { char *arglist[MAXARGS+1]; int numargs; char argbuf[ARGLEN]; numargs = 0; while ( numargs < MAXARGS ) { printf("Arg[%d]? ", numargs); if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' ) arglist[numargs++] = makestring(argbuf); else { if ( numargs > 0 ){ arglist[numargs]=NULL; execute( arglist ); numargs = 0; } } } return 0; }这个代码就相当于你输入要执行的指令，回车表示输入结束，然后输入的每个参数对应到函数中，再调用对应的指令。
结果：
psh2
代码：
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <signal.h> #define MAXARGS 20 #define ARGLEN 100 char *makestring( char *buf ) { char *cp; buf[strlen(buf)-1] = '\0'; cp = malloc( strlen(buf)+1 ); if ( cp == NULL ){ fprintf(stderr,"no memory\n"); exit(1); } strcpy(cp, buf); return cp; } void execute( char *arglist[] ) { int pid,exitstatus; pid = fork(); switch( pid ){ case -1: perror("fork failed"); exit(1); case 0: execvp(arglist[0], arglist); perror("execvp failed"); exit(1); default: while( wait(&exitstatus) != pid ) ; printf("child exited with status %d,%d\n", exitstatus>>8, exitstatus&0377); } } int main() { char *arglist[MAXARGS+1]; int numargs; char argbuf[ARGLEN]; numargs = 0; while ( numargs < MAXARGS ) { printf("Arg[%d]? ", numargs); if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' ) arglist[numargs++] = makestring(argbuf); else { if ( numargs > 0 ){ arglist[numargs]=NULL; execute( arglist ); numargs = 0; } } } return 0; }比起1来，多了循环判断，不退出的话就会一直要你输入指令，并且对于子程序存在的状态条件。
结果如下：
testbuf
testbuf1：
#include <stdio.h> #include <stdlib.h> int main() { printf("hello"); fflush(stdout); while(1); }效果是先输出hello，然后换行。之后不退出。
testbuf2
#include <stdio.h> int main() { printf("hello\n"); while(1); }效果同上。
可知：fflush(stdout)的效果和换行符\n是一样的。
testbuf3
#include <stdio.h> int main() { fprintf(stdout, "1234", 5); fprintf(stderr, "abcd", 4); }将内容格式化输出到标准错误、输出流中。结果如图：
testpid
#include <stdio.h> #include <unistd.h> #include <sys/types.h> int main() { printf("my pid: %d \n", getpid()); printf("my parent's pid: %d \n", getppid()); return 0; }输出当前进程pid和当前进程的父进程的pid。
testpp
#include <stdio.h> #include <stdlib.h> int main() { char **pp; pp[0] = malloc(20); return 0; }这个结果：
不知道为什么……
testsystem
#include <stdlib.h> int main ( int argc, char *argv[] ) { system(argv[1]); system(argv[2]); return EXIT_SUCCESS; } /* ---------- end of function main ---------- */system()——执行shell命令,也就是向dos发送一条指令。这里是后面可以跟两个参数，然后向dos发送这两个命令，分别执行。如下图，输入ls和dir两个指令后，可以看到分别执行了。
waitdemo1
#include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #define DELAY 4 void child_code(int delay) { printf("child %d here. will sleep for %d seconds\n", getpid(), delay); sleep(delay); printf("child done. about to exit\n"); exit(17); } void parent_code(int childpid) { int wait_rv=0; /* return value from wait() */ wait_rv = wait(NULL); printf("done waiting for %d. Wait returned: %d\n", childpid, wait_rv); } int main() { int newpid; printf("before: mypid is %d\n", getpid()); if ( (newpid = fork()) == -1 ) perror("fork"); else if ( newpid == 0 ) child_code(DELAY); else parent_code(newpid); return 0; }如果有子进程，则终止子进程，成功返回子进程pid。结果如下图：
waitdemo2
#include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #define DELAY 10 void child_code(int delay) { printf("child %d here. will sleep for %d seconds\n", getpid(), delay); sleep(delay); printf("child done. about to exit\n"); exit(27); } void parent_code(int childpid) { int wait_rv; int child_status; int high_8, low_7, bit_7; wait_rv = wait(&child_status); printf("done waiting for %d. Wait returned: %d\n", childpid, wait_rv); high_8 = child_status >> 8; /* 1111 1111 0000 0000 */ low_7 = child_status & 0x7F; /* 0000 0000 0111 1111 */ bit_7 = child_status & 0x80; /* 0000 0000 1000 0000 */ printf("status: exit=%d, sig=%d, core=%d\n", high_8, low_7, bit_7); } int main() { int newpid; printf("before: mypid is %d\n", getpid()); if ( (newpid = fork()) == -1 ) perror("fork"); else if ( newpid == 0 ) child_code(DELAY); else parent_code(newpid); }这个比起1来就是多了一个子进程的状态区分，把状态拆分成三块，exit，sig和core。具体运行如下：
sigdemo
sigdemo1很简单。
sigdemo2一直输出hello我停止不了，只能强行关掉终端_(:з」∠)_
sigdemo3会把你输入的内容再输出到屏幕上，输入quit结束。
argtest.c
程序代码：
#include <stdio.h> #include <stdlib.h> #include "argv.h" int main(int argc, char *argv[]) { char delim[] = " \t"; int i; char **myargv; int numtokens; if (argc != 2) { fprintf(stderr, "Usage: %s string\n", argv[0]); return 1; } if ((numtokens = makeargv(argv[1], delim, &myargv)) == -1) { fprintf(stderr, "Failed to construct an argument array for %s\n", argv[1]); return 1; } printf("The argument array contains:\n"); for (i = 0; i < numtokens; i++) printf("%d:%s\n", i, myargv[i]); execvp(myargv[0], myargv); return 0; }功能：将输入字符串当做系统命令执行。
运行结果：
environ.c
程序代码：
#include <stdio.h> #include <stdlib.h> int main(void) { printf("PATH=%s\n", getenv("PATH")); setenv("PATH", "hello", 1); printf("PATH=%s\n", getenv("PATH")); #if 0 printf("PATH=%s\n", getenv("PATH")); setenv("PATH", "hellohello", 0); printf("PATH=%s\n", getenv("PATH")); printf("MY_VER=%s\n", getenv("MY_VER")); setenv("MY_VER", "1.1", 0); printf("MY_VER=%s\n", getenv("MY_VER")); #endif return 0; }运行效果：
environvar.c
运行代码：
#include <stdio.h> int main(void) { extern char **environ; int i; for(i = 0; environ[i] != NULL; i++) printf("%s\n", environ[i]); return 0; }功能：打印环境变量。
运行效果：
sigactdemo.c
程序代码：
#include <stdio.h> #include <unistd.h> #include <signal.h> #define INPUTLEN 100 void inthandler(); int main() { struct sigaction newhandler; sigset_t blocked; char x[INPUTLEN]; newhandler.sa_handler = inthandler;//新的信号处理函数效果与signal（）类似 newhandler.sa_flags = SA_RESTART|SA_NODEFER |SA_RESETHAND;//设置信号处理相关操作 sigemptyset(&blocked); //将blocked信号集初始化，并清空。 sigaddset(&blocked, SIGQUIT);//将SIGQUIT信号加入参数blocked信号集。 newhandler.sa_mask = blocked;//暂时将block信号阻塞 if (sigaction(SIGINT, &newhandler, NULL) == -1) perror("sigaction"); else while (1) { fgets(x, INPUTLEN, stdin); printf("input: %s", x); } return 0; } void inthandler(int s) { printf("Called with signal %d\n", s); sleep(s * 4); printf("done handling signal %d\n", s); }sigation结构体：
struct sigaction { void (*sa_handler)(int); void (*sa_sigaction)(int, siginfo_t *, void *); sigset_t sa_mask; int sa_flags; void (*sa_restorer)(void); }- sa_handler此参数和signal()的参数handler相同，代表新的信号处理函数，其他意义请参考signal()。
- sa_mask 指定在信号处理程序执行过程中，哪些信号应当被阻塞。默认当前信号本身被阻塞。
- sa_restorer 已过时，POSIX不支持它，不应再使用。
- sa_flags 用来设置信号处理的其他相关操作，下列的数值可用。
- sa_flags还可以设置其他标志：
- SA_RESETHAND：当调用信号处理函数时，将信号的处理函数重置为缺省值SIG_DFL
- SA_RESTART：如果信号中断了进程的某个系统调用，则系统自动启动该系统调用
- SA_NODEFER ：一般情况下， 当信号处理函数运行时，内核将阻塞该给定信号。但是如果设置了 SA_NODEFER标记， 那么在该信号处理函数运行时，内核将不会阻塞该信号
运行效果：
sigactdemo2.c
运行效果：
sigdemo1.c
#include <stdio.h> #include <signal.h> void f(int); int main() { int i; signal( SIGINT, f );//改变键盘ctril+C处理函数 for(i=0; i<5; i++ ){ printf("hello\n"); sleep(2); } return 0; } void f(int signum) { printf("OUCH!\n"); }运行效果：
sigdemo2.c
#include <stdio.h> #include <signal.h> main() { signal( SIGINT, SIG_IGN );//设置忽略Ctrl+C中断信号。 printf("you can't stop me!\n"); while( 1 ) { sleep(1); printf("haha\n"); } }运行效果：
sigdemo3.c
程序代码：
#include <stdio.h> #include <string.h> #include <signal.h> #include <unistd.h> #define INPUTLEN 100 int main(int argc, char *argv[]) { void inthandler(int); void quithandler(int); char input[INPUTLEN]; int nchars; signal(SIGINT, inthandler);//^C signal(SIGQUIT, quithandler);//^\ do { printf("\nType a message\n"); nchars = read(0, input, (INPUTLEN - 1)); if (nchars == -1) perror("read returned an error"); else { input[nchars] = '\0'; printf("You typed: %s", input); } } while (strncmp(input, "quit", 4) != 0); return 0; } void inthandler(int s) { printf(" Received signal %d .. waiting\n", s); sleep(2); printf(" Leaving inthandler \n"); } void quithandler(int s) { printf(" Received signal %d .. waiting\n", s); sleep(3); printf(" Leaving quithandler \n"); }运行效果：
参考资料
（1）百度百科
（2）《深入理解计算机系统》第8章异常控制流