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

我的代码终于检查通过了。但愿能多加些分数回来，这周我看是总结三周的总结，我先把网址打上。

十一周： http://www.cnblogs.com/20145207lza/p/6107397.html

十周 ：http://www.cnblogs.com/20145207lza/p/6081248.html#3562176

九周：http://www.cnblogs.com/20145207lza/p/6056976.html

加上一些总结：

sigactdemo

#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;
    newhandler.sa_flags = SA_RESTART|SA_NODEFER|SA_RESETHAND;
    sigemptyset(&blocked);
    sigaddset(&blocked, SIGQUIT);
    newhandler.sa_mask = blocked;
    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);
}
  • 参数结构sigaction定义如下

    struct sigaction {
    void (*sa_handler)(int);
    void (*sa_sigaction)(int, siginfo_t *, void *);
    sigset_t sa_mask;
    int sa_flags;
    void (*sa_restorer)(void);
}
  • flag
    • SA_RESETHAND：当调用信号处理函数时，将信号的处理函数重置为缺省值SIG_DFL
    • SA_RESTART：如果信号中断了进程的某个系统调用，则系统自动启动该系统调用
    • SA_NODEFER ：一般情况下， 当信号处理函数运行时，内核将阻塞该给定信号。但是如果设置SA_NODEFER标记， 那么在该信号处理函数运行时，内核将不会阻塞该信号
  • 函数sigaction 
    int sigaction(int signum,const struct sigaction *act ,struct sigaction *oldact);
    • sigaction()会依参数signum指定的信号编号来设置该信号的处理函数。参数signum可以指定SIGKILL和SIGSTOP以外的所有信号。

sigactdemo2

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

void sig_alrm( int signo )
{
    /*do nothing*/
}

unsigned int mysleep(unsigned int nsecs)
{
    struct sigaction newact, oldact;
    unsigned int unslept;

    newact.sa_handler = sig_alrm;
    sigemptyset( &newact.sa_mask );
    newact.sa_flags = 0;
    sigaction( SIGALRM, &newact, &oldact );

    alarm( nsecs );
    pause();

    unslept = alarm ( 0 );
    sigaction( SIGALRM, &oldact, NULL );

    return unslept;
}

int main( void )
{
    while( 1 )
    {
        mysleep( 2 );
        printf( "Two seconds passed\n" );
    }
    return 0;
}
  • 每两秒输出一次

sigdemo1

#include    <stdio.h>
#include    <signal.h>
void    f(int);
int main()
{
    int i;
    signal( SIGINT, f );
    for(i=0; i<5; i++ ){
        printf("hello\n");
        sleep(2);
    }

    return 0;
}

void f(int signum)
{
    printf("OUCH!\n");
}
  • 连续输出五个hello，每两个间隔是两秒
  • 在这期间，每次输入的Ctrl+C都被处理成打印OUCH

sigdemo2

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

main()
{
    signal( SIGINT, SIG_IGN );

    printf("you can‘t stop me!\n");
    while( 1 )
    {
        sleep(1);
        printf("haha\n");
    }
}
  • 一直输出haha，按Ctrl+C不能停止。Ctrl+x才行
  • SIG_DFL,SIG_IGN 分别表示无返回值的函数指针，指针值分别是0和1，这两个指针值逻辑上讲是实际程序中不可能出现的函数地址值。
    • SIG_DFL：默认信号处理程序
    • SIG_IGN：忽略信号的处理程序

sigdemo3

#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");
}
  • 多信号处理SIGX打断SIGX的情况

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;
}
int execvp(const char file ,char const argv []);
  • execvp()会从PATH 环境变量所指的目录中查找符合参数file 的文件名，找到后便执行该文件，然后将第二个参数argv传给该欲执行的文件。
  • 如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。
  • 在执行时exevp函数调用成功没有返回，所以没有打印“* * * ls is done. bye”

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\n");
    execvp( arglist[0] , arglist );
    printf("* * * ls is done. bye\n");
}
  • exec1传的是ls，exec2传送的是arglist[0]，但运行结果是相同的。

exer3

#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");
}
  • int execlp(const char * file,const char * arg,....);
  • execlp()会从PATH 环境变量所指的目录中查找符合参数file的文件名，找到后便执行该文件，然后将第二个以后的参数当做该文件的argv[0]、argv[1]……，最后一个参数必须用空指针(NULL)作结束。
  • 指定了环境变量，然后依然执行了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。
  • 父进程通过调用fork函数创建一个新的运行子进程。
  • 调用一次，返回两次。一次返回到父进程，一次返回到新创建的子进程。

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输出。

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;
}
  • 依次你输入要执行的指令与参数，回车表示输入结束，然后输入的每个参数对应到函数中，再调用对应的指令。
  • 第一个是程序名，然后依次是程序参数。
  • 一个字符串，一个字符串构造参数列表argist，最后在数组末尾加上NULL
  • 将arglist[0]和arglist数组传给execvp。
  • 程序正常运行，execvp命令指定的程序代码覆盖了shell程序代码，并在命令结束之后退出，shell就不能再接受新的命令。

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;
}
  • 比起psh1多了循环判断，不退出的话就可以一直保持在输入指令，并且对于子程序存在的状态条件。
  • 为了解决这个问题，程序通过调用fork来复制自己。
  • 调用fork函数之后内核的工作过程： 
    分配新的内存块和内核数据结构
复制原来的进程到新的进程
向运行进程集添加新的进程
将控制返回给两个进程

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。

考试加油！

时间： 2024-10-11 10:17:32

20145207《信息安全系统设计基础》第十二周学习总结的相关文章

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

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

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

一.学习目标 1.掌握进程控制 2.掌握信号处理的方法 3.掌握管道和fifo进行进程间通信的方法 二.学习资源 编译.运行.阅读.理解process.tar.gz压缩包中的代码 三.编译.运行.阅读.理解代码 (1)exec1 execvp函数 表头文件: #include 定义函数: int execvp(const char file ,char const argv []); execvp()会从PATH 环境变量所指的目录中查找符合参数file 的文件名,找到后便执行该文件,然后将第二

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

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

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

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

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

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

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

20135304刘世鹏——信息安全系统设计基础第十二周总结

一.代码理解 1.env文件夹-environ.c代码 #include <stdio.h> #include <stdlib.h> int main(void) { printf("PATH=%s\n", getenv("PATH"));//getenv函数用来取得参数PATH环境变量的值,执行成功则返回该内容的指针 setenv("PATH", "hello", 1);//见下方解释 printf(

信息安全系统设计基础第十五周总结

信息安全系统设计基础第十五周总结 [内容:链接汇总] 一.每周读书笔记链接汇总 [第一周读书笔记] http://www.cnblogs.com/shadow135211/p/4824555.html [第二周读书笔记] http://www.cnblogs.com/shadow135211/p/4842258.html [第三周读书笔记] http://www.cnblogs.com/shadow135211/p/4854920.html [第四周读书笔记] (读书笔记从“第一周”开始命名,为

20145216史婧瑶《信息安全系统设计基础》第十一周学习总结

20145216史婧瑶<信息安全系统设计基础>第十一周学习总结 教材内容总结 第八章 异常控制流 平滑:指在存储器中指令都是相邻的. 突变:出现不相邻,通常由诸如跳转.调用.和返回等指令造成. 异常控制流ECF:即这些突变. 关于ECF: 1.ECF是操作系统用来实现I/O.进程和虚拟存器的基本机制 2.应用程序通过使用一个叫做陷阱或者系统调用的ECF形式,向操作系统请求服务 3.ECF是计算机系统中实现并发的基本机制 4.软件异常机制--C++和Java有try,catch,和throw,C