zoukankan html css js c++ java

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
");
    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
");

    execlp("ls", "ls", "-l", NULL);
    printf("* * * ls is done. bye
");
}

这个代码里使用了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
", mypid);
    ret_from_fork = fork();
    sleep(1);
    printf("After: my pid is %d, fork() said %d
",
            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
", getpid() );
    fork();
    fork();
    printf("aftre:my pid is %d
", 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
", 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
", getpid());
    
        exit(0);
    }
    else{
        printf("I am the parent. my child is %d
", 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
", 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
", getpid());
        printf("parent pid= %d, my pid=%d
", getppid(), getpid());
        exit(0);
    }

    else{
        printf("I am the parent. my child is %d
", 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
", li++);
            sleep(1);
            printf("child gi:%d
", gi++);
            printf("child si:%d
", si++);
        }
        exit(0);
        
    }
    else{
        for(i=0; i<5; i++){
            printf("parent li:%d
", li++);
            printf("parent gi:%d
", gi++);
            sleep(1);
            printf("parent si:%d
", 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] = '';      
    cp = malloc( strlen(buf)+1 );       
    if ( cp == NULL ){          
        fprintf(stderr,"no memory
");
        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 != '
' )
            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] = '';      
    cp = malloc( strlen(buf)+1 );       
    if ( cp == NULL ){          
        fprintf(stderr,"no memory
");
        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
",
                    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 != '
' )
            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
");
    while(1);
}

效果同上。

可知：fflush(stdout)的效果和换行符是一样的。

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 
", getpid());
    printf("my parent's pid: %d 
", 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
", getpid(), delay);
    sleep(delay);
    printf("child done. about to exit
");
    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
", 
            childpid, wait_rv);
}
int main()
{
    int  newpid;
    printf("before: mypid is %d
", 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
", getpid(), delay);
    sleep(delay);
    printf("child done. about to exit
");
    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
", 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
", high_8, low_7, bit_7);
}

int main()
{
    int  newpid;

    printf("before: mypid is %d
", 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[] = " 	";
int i;
char **myargv;
   int numtokens;

   if (argc != 2) {
     fprintf(stderr, "Usage: %s string
", argv[0]);
      return 1;
}   
if ((numtokens = makeargv(argv[1], delim, &myargv)) == -1) {
      fprintf(stderr, "Failed to construct an argument array for %s
", argv[1]);
     return 1;
} 
printf("The argument array contains:
");
for (i = 0; i < numtokens; i++)
      printf("%d:%s
", i, myargv[i]);

   execvp(myargv[0], myargv);

   return 0;
}

功能：将输入字符串当做系统命令执行。

运行结果：

environ.c

程序代码：

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    printf("PATH=%s
", getenv("PATH"));
    setenv("PATH", "hello", 1);
    printf("PATH=%s
", getenv("PATH"));
#if 0
    printf("PATH=%s
", getenv("PATH"));
    setenv("PATH", "hellohello", 0);
    printf("PATH=%s
", getenv("PATH"));


    printf("MY_VER=%s
", getenv("MY_VER"));
    setenv("MY_VER", "1.1", 0);
    printf("MY_VER=%s
", 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
", 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
", s);
    sleep(s * 4);
    printf("done handling signal %d
", 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
");
        sleep(2);
    }

    return 0;
}

void f(int signum)          
{
    printf("OUCH!
");
}

运行效果：

sigdemo2.c

#include    <stdio.h>
#include    <signal.h>

main()
{
    signal( SIGINT, SIG_IGN );//设置忽略Ctrl+C中断信号。

    printf("you can't stop me!
");
    while( 1 )
    {
        sleep(1);
        printf("haha
");
    }
}

运行效果：

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("
Type a message
");
        nchars = read(0, input, (INPUTLEN - 1));
        if (nchars == -1)
            perror("read returned an error");
        else {
            input[nchars] = '';
            printf("You typed: %s", input);
        }
    }
    while (strncmp(input, "quit", 4) != 0);
    return 0;
}

void inthandler(int s)
{
    printf(" Received signal %d .. waiting
", s);
    sleep(2);
    printf("  Leaving inthandler 
");
}

void quithandler(int s)
{
    printf(" Received signal %d .. waiting
", s);
    sleep(3);
    printf("  Leaving quithandler 
");
}

运行效果：

参考资料

（1）百度百科

（2）《深入理解计算机系统》第8章异常控制流

查看全文

相关阅读:
SpringMVC参数校验
 SpringBoot2集成Activiti6
spring boot与activiti集成实战转
 使用国内阿里maven私服方法
 springboot2.04与activiti 6.0集成
 idea actiBPM插件生成png文件 (解决没有Diagrams或Designer选项问题)
嵌入式Qt-4.8.6显示中文并且改变字体大小和应用自己制作的字体库
 基于Qt Assistant制作软件帮助文档
 推荐一本书，30天自制操作系统
 Qt5 UI信号、槽自动连接的控件重名大坑（UI生成的槽函数存在一个隐患，即控件重名。对很复杂的控件，不要在 designer 里做提升，而是等到程序启动后，再动态创建，可以避免很多问题）

原文地址：https://www.cnblogs.com/20135223heweiqin/p/5006070.html