20135321余佳源——信息安全系统设计基础第十二周学习总结
2015-11-29 21:39
399 查看
20135321余佳源——信息安全系统设计基础第十二周学习总结
标签(空格分隔):20135321余佳源第十二周(11.23-11.29):
学习计时:共6小时
读书:3
代码:1
作业:1
博客:1
一、学习目标
掌握进程控制
掌握信号处理的方法
掌握管道和fifo进行进程间通信的方法
二、学习资源
编译、运行、阅读、理解process.tar.gz压缩包中的代码
exec1
#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; }
可以看到这个代码中用了execvp函数。
表头文件: #include 定义函数: int execvp(const char file ,char const argv []);
exec1.c编译并运行程序结果如下:
execvp()会从PATH 环境变量所指的目录中查找符合参数file 的文件名,找到后便执行该文件,然后将第二个参数argv传给该欲执行的文件。
如果执行成功则函数不会返回,执行失败则直接返回-1,失败原因存于errno中。
可以看到,exevp函数调用成功没有返回,所以没有打印出“* * * ls is done. bye”这句话。
exec2
exec2与exec1的区别就在于,execvp函数调用的语句变成了execvp( arglist[0] , arglist );
不过由定义可得这两个等价,所以运行结果是相同的。
编译运行结果与exec1.c完全相同,说明arglist数组的第一项为要运行的程序的名称。
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
这个代码先是打印进程pid,然后调用fork函数生成子进程,休眠一秒后再次打印进程id,这时父进程打印子进程pid,子进程返回0。代码如下:
#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; }
在Unix/Linux中用fork函数创建一个新的进程。进程是由当前已有进程调用fork函数创建,分叉的进程叫子进程,创建者叫父进程。该函数的特点是调用一次,返回两次,一次是在父进程,一次是在子进程。两次返回的区别是子进程的返回值为0,父进程的返回值是新子进程的ID。子进程与父进程继续并发运行。如果父进程继续创建更多的子进程,子进程之间是兄弟关系,同样子进程也可以创建自己的子进程,这样可以建立起定义关系的进程之间的一种层次关系。
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; }
这个代码也是打印进程pid,然后调用fork函数生成子进程,因为调用两次fork,一共产生四个子进程,所以会打印四个after输出。
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来,多了循环判断,不退出的话就会一直要你输入指令,并且对于子程序存在的状态条件。
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); }
程序输出hello,无法退出。
PS:可知: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; } /* --------
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。
总结
对于exec函数:在Linux中要使用exec函数族。系统调用execve()对当前进程进行替换,替换者为一个指定的程序,其参数包括文件名(filename)、参数列表(argv)以及环境变量(envp)。exec函数族当然不止一个,但它们大致相同,在 Linux中,它们分别是:execl,execlp,execle,execv,execve和execvp。一个进程一旦调用exec类函数,它本身就"死亡"了,系统把代码段替换成新的程序的代码,废弃原有的数据段和堆栈段,并为新程序分配新的数据段与堆栈段,唯一留下的,就是进程号,也就是说,对系统而言,还是同一个进程,不过已经是另一个程序了。若是想启动另一程序的执行但自己仍想继续运行的话,那就得结合fork与exec的使用。
对于fork函数:
fork函数启动一个新的进程,前面我们说过,这个进程几乎是当前进程的一个拷贝:子进程和父进程使用相同的代码段;子进程复制父进程的堆栈段和数据段。这样,父进程的所有数据都可以留给子进程,但是,子进程一旦开始运行,虽然它继承了父进程的一切数据,但实际上数据却已经分开,相互之间不再有影响了,也就是说,它们之间不再共享任何数据了。
问题:
运行testpp时,出现段错误(核心已转储),不知道原因。理解代码时,对于管道实现父子进程之间通信不理解。
其基本原理是这样的:假如原先在父进程中文件描述符3和4通过管道1连接起来(3是读端,4是写端),则fork创建子进程后,子进程中的文件描述符3和4也通过管道1连接起来(3是读端,4是写端)。这样一来,在父进程通过文件描述符4向管道写入内容后,在子进程中就可以通过文件描述符3从管道中读出数据(当然在父进程中也可以通过文件描述符3从管道中读出数据)。
参考资料
《进程间通信-命名管道FIFO》(http://blog.csdn.net/xiajun07061225/article/details/8471777)《linux i/o重定向与管道编程》
(http://blog.csdn.net/fulianzhou/article/details/48895327)
教材:第八章,详细学习指导:http://group.cnblogs.com/topic/73069.html
闫佳歆同学的博客:http://www.cnblogs.com/20135202yjx/p/5003653.html
相关文章推荐
- 数据结构基础7.3:堆排序
- form表单
- Hibernate的关系映射
- java 解决oracle US7ASCII编码,sql查询时
- Looper
- MFC模态对话框和非模态对话框
- 判断二进制数1的个数
- 【openjudge】踩方格
- C语言中关于数字的一些小程序
- Mysql查询缓存碎片、缓存命中率及Nagios监控
- 1090. Highest Price in Supply Chain
- Jenkins xcodebuild There are no schemes in workspace
- 电脑基本信息
- ios 测试用例
- HDU-3177 Crixalis's Equipment
- TCP/IP详解之:IP选路 动态选路协议
- samba 服务
- 犯错,帮助我们成长
- springIDE
- 发布iOS企业分发(二)(iOS开发环境配置)