V3.0_用exec族函数替代system()

yrx020307

已于 2023-05-29 21:44:46 修改

阅读量668

点赞数

文章标签： linux

于 2023-05-29 21:38:42 首次发布

本文链接：https://blog.csdn.net/yrx020307/article/details/130931190

版权

linux系统编程小项目专栏收录该内容

9 篇文章 0 订阅

订阅专栏

该文章详细介绍了如何使用exec族函数在Linux中创建子进程并替换子进程的执行上下文。当exec函数成功执行后，子进程会终止，结束状态为0，不会返回到原程序。文章通过示例代码展示了在不同命令操作（如创建、写入、显示和删除文件）中如何运用fork和exec族函数进行进程间的协作。

摘要由CSDN通过智能技术生成

注意点：exec族函数的使用

以execl为例：

（1）

（2）exec族函数中的函数调用失败时会设置error并返回-1，然后从源程序调用点接着往下执行。
执行成功后不会返回，也不会从源程序调用点接着往下执行。

exec族函数一般配合fork使用；

创建子进程后，在子进程中调用exec组函数处理事情；

exec族函数允许成功后不会返回，也不会继续执行，而是结束子进程，且子进程的结束状态为0（相当于调用exit(0)结束子进程）

二，验证“exec族函数允许成功后不会返回，也不会继续执行，而是结束子进程，且子进程的结束状态为0（相当于调用exit(0)结束子进程）”

父进程在等待子进程结束，如果子进程结束了，会打印结束状态；

函数中未使用exit(0);

status_childProcess初值被设置为-1了；

子进程结束状态为0；

证明execl运行成功后主动结束了子进程；

程序的完整代码：

mainc


#include "./io.h"

struct CMD_input CMD_test1={"creat","copy","display","delete","write"};
struct buffer_param *p;

int main(int argc,char **argv)
{
    //printf("argc :%d,argv[0]:%s,argv[1]:%s,argv[2]:%s\r\n",argc,argv[0],argv[1],argv[2]);
    //agrc指在终端输入的个数
    //argv[0]是第1个参数；
    //argv[1]是第二个参数；，，，，，，
    
    //1-function:解析参数1。判断要做什么操作
    //当前只接解析“creat”,但是预留“cp”,"display","delete"接口
    
    p = ( struct buffer_param *)malloc(sizeof(struct buffer_param));
    memset(p,0,sizeof(struct buffer_param));
    strncpy(p->buffer_param0,argv[0],strlen(argv[0]));
    strncpy(p->buffer_param1,argv[1],strlen(argv[1]));
    strncpy(p->buffer_param2,argv[2],strlen(argv[2]));
    if(argc==4)
    {
        strncpy(p->buffer_param3,argv[3],strlen(argv[3]));
    }
    


    log_test1();//打印所有参数
    read_CMD();//读取指令“creat,write,delete,display,copy”
    task_sch();//执行任务




    return 0;
}

io.c

#include "./io.h"
extern struct buffer_param *p;
extern struct CMD_input CMD_test1;
int flag_of_QUITEDIT=0;
char path_of_file[30];
char flag_of_key_event=0;

void log_test1()
{
    printf("param0:%s\r\n",p->buffer_param0);
    printf("param1:%s\r\n",p->buffer_param1);
    printf("param2:%s\r\n",p->buffer_param2);
    printf("param3:%s\r\n",p->buffer_param3);
}
int read_CMD()
{
    if(strncmp(p->buffer_param1,CMD_test1.CMD_CREAT,strlen(p->buffer_param1))==0)//creat
    {
        memset(path_of_file,0,sizeof(path_of_file));
        sprintf(path_of_file,"./%s",p->buffer_param2);
        flag_of_key_event = Key_event_creatFile;
        //creat(buffer_param2, S_IRWXU);
    }
    else if(strncmp(p->buffer_param1,CMD_test1.CMD_WRITE,strlen(p->buffer_param1))==0)//write
    {
        memset(path_of_file,0,sizeof(path_of_file));
        sprintf(path_of_file,"./%s",p->buffer_param2);
        flag_of_key_event = Key_event_writeFile;///写入数据
    }    
    else if(strncmp(p->buffer_param1,CMD_test1.CMD_DISPLAY,strlen(p->buffer_param1))==0)//display
    {
        memset(path_of_file,0,sizeof(path_of_file));
        sprintf(path_of_file,"cat ./%s",p->buffer_param2);
        flag_of_key_event = Key_event_displayFile;///
    } 
    else if(strncmp(p->buffer_param1,CMD_test1.CMD_CP,strlen(p->buffer_param1))==0)//copy
    {
        memset(path_of_file,0,sizeof(path_of_file));
        sprintf(path_of_file,"cp ./%s ./%s",p->buffer_param2,p->buffer_param3);
        flag_of_key_event = Key_event_copyFile;///
    } 
    else if(strncmp(p->buffer_param1,CMD_test1.CMD_DELETA,strlen(p->buffer_param1))==0)//display
    {
        memset(path_of_file,0,sizeof(path_of_file));
        sprintf(path_of_file,"rm ./%s",p->buffer_param2);
        flag_of_key_event = Key_event_deleteFile;///
    } 
    return 0;
}

int task_sch()
{
    int return_of_fork;
    int status_childProcess;//子进程退出状态
    switch(flag_of_key_event)
    {
        case Key_event_creatFile:
                return_of_fork = fork();//创建1个子进程
                if(return_of_fork<0)
                    printf("creat childprocess failed\r\n");
                else if(return_of_fork==0)
                    creat_file();
                else if(return_of_fork>0)
                    wait(NULL);
            break;
        case Key_event_writeFile:
                return_of_fork = fork();//创建1个子进程
                if(return_of_fork<0)
                    printf("creat childprocess failed\r\n");
                else if(return_of_fork==0)
                    write_file();
                else if(return_of_fork>0)
                    wait(&status_childProcess);
                    printf("child process exit status:%d\n",WEXITSTATUS(status_childProcess));
            break;
        case Key_event_displayFile:            
                return_of_fork = fork();//创建1个子进程
                if(return_of_fork<0)
                    printf("creat childprocess failed\r\n");
                else if(return_of_fork==0)
                    display_file();
                else if(return_of_fork>0)
                    wait(&status_childProcess);
                    printf("child process exit status:%d\n",WEXITSTATUS(status_childProcess));
            break;
        case Key_event_copyFile:
                return_of_fork = fork();//创建1个子进程
                if(return_of_fork<0)
                    printf("creat childprocess failed\r\n");
                else if(return_of_fork==0)
                    copy_file();
                else if(return_of_fork>0)
                    wait(&status_childProcess);
                    printf("child process exit status:%d\n",WEXITSTATUS(status_childProcess));

            break;
        case Key_event_deleteFile:
                return_of_fork = fork();//创建1个子进程
                if(return_of_fork<0)
                    printf("creat childprocess failed\r\n");
                else if(return_of_fork==0)
                    delete_file();
                else if(return_of_fork>0)
                    wait(&status_childProcess);
                    printf("child process exit status:%d\n",WEXITSTATUS(status_childProcess));
            break;            
        default :break;
    }
}

int creat_file()
{
    int ret=0;
    ret = creat(p->buffer_param2, S_IRWXU);//
    if(ret==-1)
    {
        printf("creat file failed\r\n");
    }
    exit(Key_event_creatFile);//退出子进程
    return ret;

}


int write_file()
{
    int ret=0;
    int fd=0;
    char readbuffer[128]={0};
    fd = open(path_of_file,O_RDWR | O_CREAT,0666) ;
    if(fd == -1)
	{
		printf("unexist %s\n",path_of_file);
	}	
	else
	{
		printf("open file1 success\n");
        printf("if you want exit edit ,please input “QUIT”\r\n");
        printf("please input string :\r\n");

        while(flag_of_QUITEDIT==0)
        {

            printf(">");
            memset(readbuffer,0,sizeof(readbuffer));
            fgets(&readbuffer[0],50,stdin);
            
            if(strncmp(readbuffer,"QUIT",strlen("QUIT"))==0)
            {
                flag_of_QUITEDIT=1;
            }
            //add"enter"to string
            {
                int len;
                len = strlen(readbuffer);
                readbuffer[len] = '\n';
                readbuffer[len+1] = '\0';
            }

            
            ret = write(fd,readbuffer,strlen(readbuffer));
            if(ret == -1)
            {
                perror("write");
                exit(-1);
            }
            if(flag_of_QUITEDIT==1)
            {
                close(fd);
                exit(Key_event_writeFile);
            }
        }

        }
}


int display_file()
{
    int fd=0;
    //fd = system(path_of_file);
    //printf("fd = %d\r\n",fd);
    fd = execl_for_cat();
    if(fd>0)
    {
        printf("cat file failed\r\n");
    }
    close(fd);
    //exit(Key_event_displayFile);
}

int copy_file()
{
    int fd=0;
    int fdSRC=0;
    int fdDES=0;
    char *readBuf = NULL;
    //fd = system(path_of_file);
    //printf("fd = %d\r\n",fd);
    //使用lseek实现copy;源文件：p->buffer_param2；目标文件：p->buffer_param3
    fdSRC = open(p->buffer_param2,O_RDWR);//打开文件
    if(fdSRC==-1)
    {
        printf("src open failed\r\n");
    }
    else{
        //源文件打开成功
        int size = lseek(fdSRC,0,SEEK_END);//读取文件大小
        lseek(fdSRC,0,SEEK_SET);//把光标移动到文件头部
        readBuf = (char *)malloc(sizeof(char)*size + 8);//指针指向这么大的空间
        int n_read = read(fdSRC, readBuf, 1024);//把源文件的数据读取到buffer中

        fdDES = open(p->buffer_param3,O_RDWR|O_CREAT,0600);//创建目标文件
        int n_write = write( fdDES,readBuf,strlen(readBuf));//向目标文件写入信息
        close(fdSRC);
	    close(fdDES);
 	    exit(Key_event_copyFile);
    }


    
}


int delete_file()
{
    int fd=0;
    fd = system(path_of_file);
    //printf("fd = %d\r\n",fd);
    if(fd!=0)
    {
        printf("delete file failed\r\n");
    }
    exit(Key_event_deleteFile);
}


int execl_for_cat()
{
    memset(path_of_file,0,sizeof(path_of_file));
    sprintf(path_of_file,"./%s",p->buffer_param2);
    printf("will display file by execl \r\n");
    if(execl("/bin/cat","cat",path_of_file,NULL) == -1)//exec族函数中的函数调用失败时会设置error并返回-1，然后从源程序调用点接着往下执行。执行成功后不会返回，也不会从源程序调用点接着往下执行。
	{
		printf("exec failed\n");
	}
    //return 0;
}

io.h

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#define Key_event_creatFile 0x01
#define Key_event_writeFile 0x02
#define Key_event_displayFile 0x03
#define Key_event_copyFile 0x04
#define Key_event_deleteFile 0x05
struct CMD_input{
    char CMD_CREAT[10];
    char CMD_CP[10];
    char CMD_DISPLAY[10];
    char CMD_DELETA[10];
    char CMD_WRITE[10];
};

struct buffer_param{
    char buffer_param0[10];
    char buffer_param1[10];
    char buffer_param2[10];
    char buffer_param3[10];
};
void log_test1();
int read_CMD();
int task_sch();
int creat_file();
int write_file();
int display_file();
int copy_file();
int delete_file();
int execl_for_cat();