信息安全系统设计基础第十二周学习总结 ——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
");
    execvp( "ls" , arglist );
    printf("* * * ls is done. bye");

    return 0;
}

本代码中：

arglist属于命令行参数，表示不定参数列表，表示后跟不定个参数。

这里使用execvp()函数

int execvp(const char* file, const char* argv[]);

argv列表最后一个必须是 NULL

execvp()会从PATH 环境变量所指的目录中查找符合参数file 的文件名，找到后便执行该文件，然后将第二个参数argv传给该欲执行的文件。

如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。

运行结果：

exec2

代码：

#include <stdio.h>
#include <unistd.h>

int main()
{
    char    *arglist[3];

    arglist[0] = "ls";
    arglist[1] = "-l";
    arglist[2] = 0 ;
    printf("* * * About to exec ls -l
");
    execvp( arglist[0] , arglist );
    printf("* * * ls is done. bye
");
}

exevp函数的第一个参数，exec2的参数是arglist[0]，与exec1等价，运行结果相同。

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
");
//    execv( "/bin/ls" , arglist );
//    execvp( "ls" , arglist );
//  execvpe("ls" , arglist, myenv);

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

这里使用了execlp（）函数，

#include<unistd.h>
int execlp(const char file, const char argv ...)

用法如下：

execlp("ps","ps","-au","-x",(char)0);

1.最后一个参数必须是(char)0， 如果不强制转换成char，就会自动转换成int 有未知的错误。

2.第一个参数是要运行的文件，会在环境变量PATH中查找file.

3.失败会返回－1， 成功无返回值，但是，会在当前进程运行，执行成功后，直接结束当前进程。可以在子进程中运行。 

4.第二个参数，是一个参数列表，如同在shell中调用程序一样，参数列表为0，1，2，3……因此，ps作为第0个参数，需要重复一遍。

这个代码指定了环境变量，然后依然执行了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，所以输出父进程，休眠十秒；子进程返回0，所以输出子进程。

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;
}

该代码调用一次fork，父进程先打印两句，然后休眠一秒，然后打印一句，子进程先打印一句，然后休眠一秒，然后打印两句。这两个线程是并发的，所以可以看到在一个线程休眠的那一秒，另一个线程在执行，并且线程之间相互独立互不干扰。

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;
}

该代码比psh1来，多了循环判断，不退出的话就会一直要你输入指令，并且对于子程序存在的状态条件。

testbuf1

代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    printf("hello");
    fflush(stdout);
    while(1);
}

先输出hello，然后换行。

此处用了fflush(stdout)，在printf()后使用fflush(stdout)的作用是立刻将要输出的内容输出。 
当使用printf()函数后，系统将内容存入输出缓冲区，等到时间片轮转到系统的输出程序时，将其输出。 
使用fflush（out）后，立刻清空输出缓冲区，并把缓冲区内容输出。 

testbuf2

代码：

#include <stdio.h>
int main()
{
    printf("hello
");
    while(1);
}

该程序也是先输出hello，然后换行。

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发送一条指令。

system("pause")可以实现冻结屏幕，便于观察程序的执行结果；system("CLS")可以实现清屏操作。而调用color函数可以改变控制台的前景色和背景。

返回值：

1、如果 system()在调用/bin/sh 时失败则返回127, 其他失败原因返回-1.。
2、若参数string 为空指针(NULL), 则返回非零值.
3、如果system()调用成功则最后会返回执行shell 命令后的返回值, 但是此返回值也有可能为system()调用/bin/sh 失败所返回的127, 因此最好能再检查errno 来确认执行成功.

这里是后面可以跟两个参数，然后向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，然后fork创建子进程，休眠4秒，终止子进程，返回子进程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);
}

该程序比waitdemo1多了一个子进程的状态区分，把状态拆分成三块，exit，sig和core。

参考资料:

代码

百度百科