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章异常控制流

时间: 11-29

20135223何伟钦—信息安全系统设计基础第十二周学习总结的相关文章

信息安全系统设计基础第十二周学习总结

第十二周代码学习 一.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

信息安全系统设计基础第十二周学习总结-吕松鸿

第十一章 网络编程 11.1客户端—服务器编程模型 1.一个服务器进程 -> 管理某种资源 -> 通过操作这种资源来为它的客户端提供某种服务. 2.一个或多个客户端进程. 3.基本操作:事务 当一个客户端需要服务时,向服务器发送一个请求,发起一个事务. - 服务器收到请求后,解释它,并以适当的方式操作它的资源. 服务器给客户端发送一个相应,并等待下一个请求. 客户端收到响应并处理它. 注意:客户端和服务器都是进程. 11.2网络 (1)对主机而言:网络是一种I/O设备 从网络上接收到的数据从适

20135210程涵——信息安全系统设计基础第十二周学习总结

一.exec1.c:程序调用execvp:arglist是命令行的字符串数组,数组的第一个元素为程序名称,最后一个元素必须是null. 二.exec2.: exec2与exec1的区别就在于:execvp( arglist[0] , arglist ),不过这两个等价,所以运行结果是并无不同. execlp()函数属于exec()函数族,它是execve(2)函数的前端. execlp从PATH 环境变量中查找文件并执行.execlp()会从PATH 环境变量所指的目录中查找符合参数file的文

信息安全系统设计基础第十二周学习总结 ——20135308

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

信息安全系统设计基础第十二周学习总结—20135227黄晓妍

第十二章 并发编程 操作系统提供了三种基本的构造并发程序的方法: 1.进程.每个逻辑控制流都是一个进程,由内核来调度和维护: 2.I/O多路复用. 3.线程.    一.基于进程的并发编程 在接受连接请求之后,服务器派生出一个子进程,这个子进程获得服务器描述表完整的拷贝.子进程关闭它的拷贝中监听描述符3,父进程关闭它的已连接描述符4的拷贝,因为不需要这些描述符了. 程序实例: 因为通常服务器会运行很长时间,所以需要一个SIGCHLD处理程序,来回收僵死进程.因为当SIGCHLD执行时,信号是阻塞

20135223何伟钦—信息安全系统设计基础第九周学习总结

学习目的: 1. 掌握系统编程和系统调用的概念 2. 掌握系统编程错误处理的方式 3. 掌握Unix/Linux系统级I/O(open close read write seek stat) 4. 掌握RIO 5. 掌握I/O重定向的方法 一.Unix I/O Unix I/O定义:所有的I/O设备都被模型化为文件,所有的输入和输出都被当作 对相应文件的读和写来执行.这种将设备影射为文件的方式,称为Unix I/O (一)打开文件 (1)文件描述符:一个应用程序通过要求内核打开相应的文件,来宣告

20135223何伟钦—信息安全系统设计基础第六周学习总结

第四章:处理器体系结构 ISA指令集体性结构——处理器支持的指令和指令的字节编码 HCL硬件控制语言—描述处理器设计 Y86——定义一个指令集体系结构,包括定义各种状态元素.指令集和他们的编码.一组编程规范和异常事件处理. 一.Y86指令集体系结构 (一)程序员可见的状态 1.Y86程序 每条指令都会读取或修改处理器状态的某些部分 2.程序员 可以是用汇编代码写程序的人,也可以是产生机器级代码的编译器. 3.处理器状态(类似于IA32) ①8个程序寄存器,%eax,%ecx,%edx,%ebx,

20135223何伟钦—信息安全系统设计基础第十三周学习总结

学习任务: 1. 掌握三种并发的方式:进程.线程.I/O多路复用 2. 掌握线程控制及相关系统调用 3. 掌握线程同步互斥及相关系统调用 1.并发的意义 概念:只要逻辑控制流在时间上重叠,那么就可以称为并发. 意义: 访问慢速设备(如I/O设备):[CPU可以在这样的慢速中“腾出手”再去做其他事情,使自己保持“繁忙”.] 与人交互:每次用户进行某种操作的请求的时候[用户不会在意在自己进行操作的时候系统是否还处理着其他程序],一个独立的逻辑并发流被用来处理这个程序. 通过推迟工作来降低延迟 服务多

20135223何伟钦—信息安全系统设计基础第五周学习总结

第三章 程序的机器级表示 一.历史观点 Intel处理器(X86) 二.程序编码 gcc -01 -o p p1.c p2.c ①编译选项-01 表示编译器使用第一级优化 ②编译选项-02 表示编译器使用第二级优化(较好的选择) ③-o 表示分别将p1.c和p2.c编译后的可执行文件命名为p GCC将源代码转化为可执行代码的步骤: C预处理器:扩展源代码,插入所有#include命令指定的文件,并扩展生成.i文件 编译器:产生两个源代码的汇编代码,生成.s文件 汇编器:将汇编代码转化成二进制目标