【Linux】深入理解文件操作

文章目录

      • 初次谈论文件
      • 重温C语言文件操作
      • 系统文件操作接口
        • open
        • write
        • read
      • 再次谈论文件
        • 文件描述符
        • 文件描述符的分配规则
      • 重定向
        • 什么是重定向
        • 重定向的本质
        • 系统调用接口实现重定向
        • <、>、>>

初次谈论文件

开始之前先谈论一下关于文件的一些共识性问题。

  1. 一个文件可以分为两部分，内容和属性。
  2. 基于上面的认识，空文件也要在磁盘中占据空间，因为空文件的内容为空，但是还有属性在，例如文件的创建时间… 而这部分属性也是要存储的。
  3. 所以对文件的操作就变成了对文件的内容或对文件的属性进行操作。
  4. 如果我们要标识一个文件，必须要通过路径+文件名的方式来唯一标识。
  5. 当我们使用相关方法进行文件操作的时候我们一般只写一个文件名，此时我们并没有指明文件的路径，此时默认是在当前路径(访问文件的进程的当前路径)下进行相关文件操作。
  6. 当我们写完一份代码，代码中有对文件进行操作的内容，当我们把代码编译成可执行文件后，在我们执行这个程序之前，文件操作并没有被执行，只有当我们运行这个程序，程序变成进程之后才会真正执行相应的文件操作，所以对文件操作本质上是进程对文件的操作。
  7. 我们无论是以哪种方式访问文件，前提是都要打开这个文件。而打开文件这个动作是谁完成的呢？谁能管理文件的存储谁就能打开，所以是操作系统打开的，或者准确一点，是操作系统收到进程的访问请求时打开的。所以文件操作的本质是进程和被打开文件之间的关系。

重温C语言文件操作

我们常说C默认会打开三个输入输出流：stdin、stdout、stderr，这点后面还会用到。

C语言中有诸如fopen、fclose、fprintf、fscanf、fwrite、fread等涉及文件操作的函数方法。

这里就简单回顾一下部分接口。

  1. FILE * fopen ( const char * filename, const char * mode );

    用fopen函数可以打开一个文件，参数分别是文件名和打开方式，返回一个FILE指针。

    而mode有多种选项，例如r - 只读，r+ - 可读可写，w - 只写，w+ - 可读可写，a - 追加，a+ - 可追加可读…

    除此之外还有二进制读写、文件不存在是否创建文件、文件是否会覆盖重写等细节问题。

  2. int fprintf ( FILE * stream, const char * format, ... );

    fprintf与普通的printf的区别在于printf是默认向stdout中输出打印，而fprintf则可以指定文件。

  3. …

系统文件操作接口

实际上，我们所用到的无论是C语言，还是python、Java、c++，它们的相关访问文件的接口虽然各有不同，但它们都是对系统提供的文件操作接口的封装。换句话说，各个所提提供的文件方法底层都是封装了相同的系统提供的文件操作接口。

下面就简单学习几种文件操作接口。

因为要查系统调用接口，所以在使用man手册查询的时候要加个2选项：man 2 [name]。

open

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

参数：
pathname: 要打开或创建的目标文件
flags: 打开文件时，可以传入多个参数选项，用下面的一个或者多个常量进行“或”运算，构成flags。
	O_RDONLY: 只读打开
	O_WRONLY: 只写打开
	O_RDWR : 读，写打开
 	上面三个常量，必须指定一个且只能指定一个
	O_CREAT : 若文件不存在，则创建它。需要使用mode选项，来指明新文件的访问权限
	O_APPEND: 追加写
    O_TRUNC: 清空文件
	//...
mode: 如果创建文件的话，文件的访问权限
 
返回值：
 	成功：新打开的文件描述符
 	失败：-1

这里提供了两个open函数，差别在最后一个mode参数，mode其实就是创建文件时文件的默认权限，Linux默认是0666，想了解文件权限的小伙伴可以跳转到这个链接：【Linux】对权限的初步理解_LeePlace的博客-CSDN博客。

参数pathname没什么好说的，就是要打开的文件的完整路径，不过只有文件名的话就默认当前路径。

下面着重介绍flags。

我们打开文件时是以读的方式还是以写的方式，是以文本文件的形式读写还是以二进制文件，这些信息都需要通过参数来进行信息传递。

flags是一个int整形，拥有32个bit位，我们如果给这32个bit位每一位都赋予一定意义，比如第一个bit为1就是以读的方式打开，第二个bit位为1就是以写的方式打开… 此时每一个bit都是一个标记位，而系统给我们提供了一些宏，比如O_WRONLY可能是1 << 0，O_CREAT可能是1 << 1，O_TRUNC可能是1 << 2，此时把这三个数按位或就得到一个前三个比特位都是1的flag，表示以只写、文件不存在的时候创建文件、打开时清空文件的方式来打开一个文件。

学过c++访问文件的方式的小伙伴对这种方式肯定不陌生，比如经常用到像ios::in | ios::binary的参数。

open会返回一个int，叫文件描述符，后面再对文件描述符进行更进一步的讨论。

所以我们现在就可以试着用open来打开一个文件：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    close(fd);
    return 0;
}

image-20230822141447899

因为是以只写的方式打开，文件不存在我们选择创建文件，所以可以成功创建文件，而文件的权限并不是0666，这是因为文件掩码的存在，这里就不多做解释，如果想不受文件掩码的影响可以加一句umask(0)。

当然上面还用到了close，这其实就是系统提供的关闭文件的接口，参数是要关闭文件的文件描述符，就不多做介绍了。

如果想以只读的方式打开文件，则是open(FILE_NAME, O_RDONLY);

如果想以追加的方式打开文件，则是open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);

write

NAME
	write - write to a file descriptor

SYNOPSIS
	#include <unistd.h>
	ssize_t write(int fd, const void *buf, size_t count);

DESCRIPTION
    fd: 要写入的文件描述符
    buf: 一个指针，指向待写入的数据
    count: 待写入的数据的大小，单位是字节
        
RETURN VALUE
    成功：返回写入的字节数
    失败：返回-1，并适当设置errno

所以我们可以试着用write向文件中写入：

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if(fd < 0)          //打开文件失败
    {
        perror("open");
        return 1;
    }
    int cnt = 5;
    char outBuffer[64];
    while(cnt)
    {
        //将aaaa和cnt序列化成字符串存储到outBuffer中
        sprintf(outBuffer, "%s:%d\n", "aaaa", cnt--);
        //将outBuffer的内容写入到文件中
        write(fd, outBuffer, strlen(outBuffer));
    }

    close(fd);
    return 0;
}

此时log.txt文件中就写入了我们指定的内容：

image-20230822144214732

如果我们打开文件时选择追加，上面的操作则会不断向文件中追加相同的内容。

read

NAME
	read - read from a file descriptor

SYNOPSIS
	#include <unistd.h>
	ssize_t read(int fd, void *buf, size_t count);

DESCRIPTION
	fd: 要读的文件描述符
	buf: 存放读取的数据
	count: 要读取的字节数
        
RETURN VALUE
    如果成功，则返回读取的字节数
    如果出现错误，则返回-1，并适当地设置errno

刚刚我们创建一个文件并向其中写入，现在我们试着将写入的内容读出来并进行打印：

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    int fd = open("log.txt", O_RDONLY, 0666);
    if(fd < 0)          //打开文件失败
    {
        perror("open");
        return 1;
    }

    char buffer[1024];
    ssize_t num = read(fd, buffer, sizeof(buffer) - 1); //预留一个位置存放'\0'
    if(num > 0) 
        buffer[num] = 0;
    printf("%s", buffer);

    close(fd);
    return 0;
}

image-20230822145048768

系统接口就简单介绍这么多。

再次谈论文件

文件描述符

一个进程就可以打开多个文件，而系统中又存在着这么多进程，所以系统中一定存在着大量的被打开文件，而且某些文件还可能被打开了多次，而这些被打开的文件毫无疑问也是要被操作系统所管理的。那问题来了，操作系统是怎么管理这些被打开文件的呢 —— 先描述，再组织。

为了管理文件，必定要创建相应的内核数据结构来描述文件，这个内核数据结构就是struct file，结构体内部包含了文件的大部分属性，每一个文件都有一个对应的内核数据结构struct file，将这些结构通过一定的数据结构组织起来，通过算法对这部分数据结构进行增删查改，不就实现了对文件的管理吗？

前面介绍open的时候涉及到了文件描述符的概念，我们初步知道文件描述符是一个整数，那不妨试着打印一下这个整数：

#define FILE_NAME(number) "log.txt"#number 

int main()
{
    int fd[5] = { 0 };

    fd[0] = open(FILE_NAME(1), O_WRONLY | O_CREAT | O_APPEND, 0666);
    fd[1] = open(FILE_NAME(2), O_WRONLY | O_CREAT | O_APPEND, 0666);
    fd[2] = open(FILE_NAME(3), O_WRONLY | O_CREAT | O_APPEND, 0666);
    fd[3] = open(FILE_NAME(4), O_WRONLY | O_CREAT | O_APPEND, 0666);
    fd[4] = open(FILE_NAME(5), O_WRONLY | O_CREAT | O_APPEND, 0666);

    for (int i = 0; i < 5; i++)
        printf("%d\n", fd[i]);

    return 0;
}

image-20230822150708204

此时能想到3、4、5、6、7像是数组下标，但为什么是从3开始呢？

这就涉及到前面提到的C默认打开的三个输入输出流：stdin，stdout，stderr。

我们用C语言打开文件时会返回一个FILE*，上面三个输入输出流其实也是FILE*类型的：

image-20230822151843315

FILE结构体里有一个字段_fileno，这个其实就是文件描述符，我们可以试着打印一下：

int main()
{
    printf("stdin -> %d\n", stdin->_fileno);
    printf("stdout -> %d\n", stdout->_fileno);
    printf("stderr -> %d\n", stderr->_fileno);
    return 0;
}

image-20230822152635701

带着现象和问题，下面进行讲解。

我们前面说了，C语言的一系列接口是封装的系统接口，而系统接口访问文件并不是依托文件名，而是文件描述符，那怎么通过文件描述符找到对应的文件呢？

系统为每个文件都创建了内核数据结构struct file，用以保存文件的大部分属性，而我们的进程需要找到文件，也就是进程需要通过一定的方式与许多的struct file结构关联起来，所以最好整一个指针数组，数组每一个元素都指向一个struct file，所以每个进程都有一个这样的指针数组struct file* fd_array[]，称之为文件描述符表，所以进程只需要找到这张表就能找到要访问的文件。但是进程与文件的关系不光只靠文件描述符，还有其它的一些关系需要描述，而这些描述进程和文件之间关系的字段都被封装到了一个结构体struct files_struct中，进程的PCB中间接保存了指向这个结构体的指针struct files_struct *files，这样进程和它打开的所有文件就建立起了完整的连接。

下面用一张图来描述这个连接：

image-20230822160201224

综上，我们就知道了文件描述符就是从0开始的小整数，当我们第一次打开某个文件时，OS要在内存中给文件创建内核数据结构file来描述文件，表示一个已经打开的文件对象。

而进程打开文件时，必须让进程和被打开文件关联起来，进程的PCB中有一个指针files，指向一张表files_struct，该表中有一个字段是一个指针数组fd_array，每一个元素都是指向file的指针，而文件描述符就是该数组元素的下标。

因此，只要知道了下标，就可以找到对应的文件。

文件描述符的分配规则

先看下面这段代码：

int main()
{
    int fd = open("myfile", O_RDONLY);
    if(fd < 0){
        perror("open");
        return 1;
    }
    printf("fd: %d\n", fd);
    close(fd);
    return 0;
}

运行上面的代码，结果是fd: 3。

因为每个进程默认会指向三个files，分别是标准输入，标准输出，标准错误(也是标准输出)，所以下标0、1、2都被占用了，顺着就分配到了3。

那再看下面这段代码：

int main()
{
    close(0);
    int fd = open("myfile", O_RDONLY);
    if(fd < 0){
        perror("open");
        return 1;
    }
    printf("fd: %d\n", fd);
    close(fd);
    return 0;
}

此时代码的运行结果是fd: 0。

由此我们可以推断出文件描述符的分配规则，即在files_struct数组当中，找到当前没有被使用的最小的一个下标，作为新的文件描述符。

重定向

什么是重定向

有基础的小伙伴应该听说过输入重定向、输出重定向和追加重定向。

在命令行中我们可以通过<、>、>>分别实现输入重定向、输出重定向和追加重定向。

比如下面这样：

输出重定向：

image-20230827144201979

追加重定向：

image-20230827144233758

输入重定向：

image-20230827144330491

简单看来，重定向就是本该从file1输入或向file1输出，结果却从file2中输入或向file2中输出了。

重定向的本质

上面已经铺垫好了文件描述符的内容，所以现在打开一个进程会有下面的一个关系：

image-20230827144853486

我们还说C默认会打开三个文件分别是stdin、stdout和stderr，而这三个东西的本质是指向三个FILE结构的指针，在每个FILE结构里分别存放了一个文件描述符，依次是0、1、2，所以stdin默认和0绑定，stdout默认和1绑定，stderr默认和2绑定。

所以我们像stdout中写入本质是像文件描述符1映射的文件写入，而1默认是和显示器建立映射关系的，如果我们手动改变这个映射关系呢？

以下面的代码为例：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>


int main()
{
    close(1);
    int fd = open("myfile", O_WRONLY|O_CREAT, 00644);
    if(fd < 0){
        perror("open");
        return 1;
    }
    printf("fd: %d\n", fd);
    fflush(stdout);
    close(fd);
    exit(0);
}

首先调用close接口关掉了1，也就是断掉了文件描述符1和显示器之间的映射关系：

image-20230827145340895

然后我们又打开了一个文件myfile，按照文件描述符的分配规则，1现在会和刚打开的文件建立起新的映射关系：

image-20230827145551659

此时我们再调用printf向stdout中输出会发生什么呢？

image-20230827150048369

此时并没有向显示器输出，而是输出到了新打开的文件。

再理解一下上面那个过程：

首先通过调用close接口断开1与显示器的映射关系，注意stdout并不是直接关联的显示器，而是它指向的FILE结构体对象内部存储的文件描述符是1，fd_array[1]默认指向OS给显示器创建的内核数据结构。

此时我们再打开一个文件，然后根据文件描述符的分配规则，OS发现1是空的，于是1就指向了新打开的文件，当我们用printf打印时，由于上层stdout的文件描述符还是存的1，就会在内核中寻找fd_array[1]对应的文件进行打印操作，而此时1已经不再映射显示器，而是myfile，随意此时打印的内容就到了myfile中。

所以重定向的本质是上层用到的文件描述符不变，在内核中更改文件描述符映射的文件。

系统调用接口实现重定向

我们可以通过上面的方法先close再open实现重定向，但不够优雅。

实际上操作系统也提供了实现重定向的接口dup/dup2/dup3，下面只介绍dup2：

SYNOPSIS
	#include <unistd.h>
	int dup2(int oldfd, int newfd);

DESCRIPTION
    dup2() makes newfd be the copy of oldfd, closing newfd first if necessary, but note the following:
       *  If oldfd is not a valid file descriptor, then the call fails, and newfd is not closed.
       *  If oldfd is a valid file descriptor, and newfd has the same value as oldfd, then dup2() does nothing, and returns newfd.
           
RETURN VALUE
	On success, dup2 returns the new descriptor. 
    On error, -1 is returned, and errno is set appropriately.

以上内容来自man手册。

解释一下，dup2会拷贝oldfd到newfd中，如果必要的时候会先关掉newfd，但是还有两点需要注意的：

  1. 如果oldfd是无效的文件描述符，那么调用就会失败，原有的newfd也不会关闭。
  2. 如果oldfd是有效的文件描述符，而newfd跟oldfd一样，也就是传进来的两个文件描述符是相同的，那么函数什么也不干。

此时有这样的映射关系：

image-20230827233134029

然后我们试着调用dup2(4, 1)，映射关系就会发生下面的变化：

image-20230828001912871

此时再向stdout中输出，也就完成了输出重定向。

<、>、>>

命令行解释器中我们可以通过<、>、>>分别实现输入重定向。输出重定向、追加重定向，那这是怎么实现的呢？

我们可以写一个简易的命令行解释器demo：

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <string.h>


char  lineCommand[1024];  // 接收输入的命令
char* myargv[64];         // 存储解析的命令行参数
int   lastCode;           // 保存子进程的退出码
int   lastSig;            // 保存子进程的退出信号
char  pwd[64];            // 保存当前所在文件路径


//解析当前位于哪个文件夹下
char* get_path(char* pwd)
{
    int pre = 0, cur = 0;
    while (pwd[cur])
    {
        cur++;
        if (pwd[cur] == '/')
        {
            pre = ++cur;
        }
    }
    return pwd + pre;
}


int main()
{ 
    // 初始化pwd
    strcpy(pwd, getenv("PWD"));

    while (1)
    {
        // 打印命令行提示符，并将其从缓冲区刷新打印
        printf("[%s@%s %s]$ ", getenv("LOGNAME"), getenv("HOSTNAME"), get_path(pwd));
        fflush(stdout);   // 立即刷新stdout的缓冲区
        
        // 用户输入命令，记得去掉最后一个\n
        char* s = fgets(lineCommand, sizeof(lineCommand) - 1, stdin);   // 预留一个位置存'\0'
        assert(s != NULL);
        lineCommand[strlen(lineCommand) - 1] = 0;  // 去掉最后一个'\n'
        (void)s;   // 将s置空，意思就是后面不用s了
        
        // 将命令分解为一个个单字符串
        int i = 0;
        myargv[i++] = strtok(lineCommand, " ");
        while (myargv[i++] = strtok(NULL, " "));
        
        // 如果命令是ls，则可能需要配置颜色
        if (myargv[0] != NULL && strcmp("ls", myargv[0]) == 0)
        {
            myargv[i - 1] = (char*)"--color=auto";
            myargv[i] = NULL;
        }

        // 如果命令是ll，则需要特殊处理一下
        if (myargv[0] != NULL && strcmp("ll", myargv[0]) == 0)
        {
            myargv[0][1] = 's';
            myargv[i - 1] = (char*)"--color=auto";
            myargv[i] = (char*)"-l";
            myargv[i + 1] = NULL;
        }

        // 如果命令是echo，则在当前进程就可以完成，为内建命令
        // 这里只支持输出上个进程的退出信息和普通信息
        if (myargv[0] != NULL && myargv[1] != NULL && strcmp("echo", myargv[0]) == 0)
        {
            // 输出上一个进程的退出信息
            if (strcmp("$?", myargv[1]) == 0)
                printf("code:%d\tsig:%d\n", lastCode, lastSig);
            // 有啥输出啥
            else 
                printf("%s\n", myargv[1]);
            continue;
        }

        // 如果命令是cd，则只能在当前进程完成，因为需要修改PWD - 当前路径
        if(myargv[0] != NULL && strcmp(myargv[0], "cd") == 0)
        {
            if(myargv[1] != NULL)
            {
                chdir(myargv[1]);
                strcpy(pwd, myargv[1]);  // 当前所在文件路径也要随之改变
            }
            continue;
        }
        
        // 创建子进程进行进程替换
        pid_t id = fork();
        assert(id != -1);
        if (id == 0)
        {
            execvp(myargv[0], myargv);
            exit(1);
        }
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        assert(ret > 0);
        (void)ret;
        lastCode = (status >> 8) & 0xFF;
        lastSig = status & 0x7F;
    }

    return 0;
}

在此基础上我们可以添加重定向的功能。

首先我们定义几个宏表示重定向类型，并定义保存重定向类型和重定向文件的变量：

#define NONE_REDIR   0  // 无重定向
#define INPUT_REDIR  1  // 输入重定向
#define OUTPUT_REDIR 2  // 输出重定向
#define APPEND_REDIR 3  // 追加重定向

int redirType = NONE_REDIR;  // 记录重定向类型
char *redirFile = NULL;		 // 记录重定向文件

首先我们需要解析命令，判断当前是什么重定向类型并记录重定向的文件，所以我们可以写一个command_check函数完成这部分内容：

void command_check(char *commands)
{
    assert(commands);
    char *start = commands;
    char *end = commands + strlen(commands);

    // 开始遍历命令
    while(start < end)
    {
        // 遍历到了>，此时可能是输出重定向，也可能是追加重定向
        if(*start == '>')
        {
            // 首先将这个位置置零，之后解析命令行参数就用不到之后的内容了
            *start = '\0';
            start++;
            
            // 继续判断下一个字符，如果是追加重定向
            if(*start == '>')
            {
                // 类似这样的形式"ls -a >> file.log"
                // 首先设置重定向类型
                // 但是不要着急保存文件信息
                // 因为可能存在这种情况"ls -a >>   file.log"
                redirType = APPEND_REDIR;
                start++;
            }
            // 否则就是输出重定向
            else
            {
                redirType = OUTPUT_REDIR;
            }
            // 我们可以写一个trim_space函数或宏帮我们跳过空格
            // 之后才可保存文件信息
            trim_space(start);
            redirFile = start;
            break;
        }
        
        // 遍历到了<，此时就是输入重定向
        else if(*start == '<')
        {
            *start = '\0';
            start++;
            redirType = INPUT_REDIR;
            
            // 确保去掉先导空格才可记录重定向文件
            trim_space(start);
            redirFile = start;
            break;
        }
        else
        {
            start++;
        }
    }
}

补充一下上面出现的trim_space函数，这里写成了宏函数的形式：

#define trimSpace(start) do{\
            while(isspace(*start)) ++start;\
        }while(0)

因为真正的命令是靠子进程来执行的，所以重定向工作需要子进程完成，并且在进程替换之前就要做好所有的重定向工作。在执行进程替换之前，需要根据父进程提供的信息判断一下是否需要重定向，如果需要的话则执行相关命令：

switch(redirType)
{
    case NONE_REDIR:
        break;
    case INPUT_REDIR:
        {
            // 先以只读的方式打开文件
            int fd = open(redirFile, O_RDONLY);
            // 如果打开文件失败就退出进程
            if(fd < 0){
                perror("open");
                exit(errno);
            }
            // 输入重定向，改变文件描述符0的指向
            dup2(fd, 0);
        }
        break;
    case OUTPUT_REDIR:
    case APPEND_REDIR:
        {
            umask(0);
            // 无论是输入重定向还是输出重定向，都需要以写的方式打开文件
            // 并且文件不存在时需要创建文件
            int flags = O_WRONLY | O_CREAT;
            // 如果是追加重定向，则添加要进行追加的信息
            if(redirType == APPEND_REDIR) 
                flags |= O_APPEND;
            // 如果是输出重定向，则需要先清空文件
            else 
                flags |= O_TRUNC;
            // 确定好打开文件的方式之后打开文件
            int fd = open(redirFile, flags, 0666);
            if(fd < 0)
            {
                perror("open");
                exit(errno);
            }
            // 输出和追加都是像显示器输出或追加，所以需要改变文件描述符1的指向
            dup2(fd, 1);
        }
        break;
}

在每次开始时都初始化一下重定向信息和错误信息，添加相关头文件，就得到了完整代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <assert.h>
#include <errno.h>


#define NONE_REDIR   0  // 无重定向
#define INPUT_REDIR  1  // 输入重定向
#define OUTPUT_REDIR 2  // 输出重定向
#define APPEND_REDIR 3  // 追加重定向

#define trim_space(start) do{\
            while(isspace(*start)) ++start;\
        }while(0)

int redirType = NONE_REDIR;  // 记录重定向类型
char *redirFile = NULL;		 // 记录重定向文件

char  lineCommand[1024];  // 接收输入的命令
char* myargv[64];         // 存储解析的命令行参数
int   lastCode;           // 保存子进程的退出码
int   lastSig;            // 保存子进程的退出信号
char  pwd[1024];          // 保存当前所在文件夹名


//解析当前位于哪个路径下
char* get_path(char* pwd)
{
    int pre = 0, cur = 0;
    while (pwd[cur])
    {
        cur++;
        if (pwd[cur] == '/')
        {
            pre = ++cur;
        }
    }
    return pwd + pre;
}


void command_check(char *commands)
{
    assert(commands);
    char *start = commands;
    char *end = commands + strlen(commands);

    // 开始遍历命令
    while(start < end)
    {
        // 遍历到了>，此时可能是输出重定向，也可能是追加重定向
        if(*start == '>')
        {
            // 首先将这个位置置零，之后解析命令行参数就用不到之后的内容了
            *start = '\0';
            start++;
            
            // 继续判断下一个字符，如果是追加重定向
            if(*start == '>')
            {
                // 类似这样的形式"ls -a >> file.log"
                // 首先设置重定向类型
                // 但是不要着急保存文件信息
                // 因为可能存在这种情况"ls -a >>   file.log"
                redirType = APPEND_REDIR;
                start++;
            }
            // 否则就是输出重定向
            else
            {
                redirType = OUTPUT_REDIR;
            }
            // 我们可以写一个trim_space函数或宏帮我们跳过空格
            // 之后才可保存文件信息
            trim_space(start);
            redirFile = start;
            break;
        }
        
        // 遍历到了<，此时就是输入重定向
        else if(*start == '<')
        {
            *start = '\0';
            start++;
            redirType = INPUT_REDIR;
            
            // 确保去掉先导空格才可记录重定向文件
            trim_space(start);
            redirFile = start;
            break;
        }
        else
        {
            start++;
        }
    }
}


int main()
{ 
    // 解析当前文件夹名
    strcpy(pwd, getenv("PWD"));

    while (1)
    {
        // 初始化重定向信息和错误信息
        redirType = NONE_REDIR;
        redirFile = NULL;
        errno = 0;
        
        // 打印命令行提示符，并将其从缓冲区刷新打印
        printf("[%s@%s %s]$ ", getenv("LOGNAME"), getenv("HOSTNAME"), get_path(pwd));
        fflush(stdout);   // 立即刷新stdout的缓冲区
        
        // 用户输入命令，记得去掉最后一个\n
        char* s = fgets(lineCommand, sizeof(lineCommand) - 1, stdin);   // 预留一个位置存'\0'
        assert(s != NULL);
        lineCommand[strlen(lineCommand) - 1] = 0;  // 去掉最后一个'\n'
        (void)s;
        
        // 将命令分解为一个个单字符串
        int i = 0;
        myargv[i++] = strtok(lineCommand, " ");
        while (myargv[i++] = strtok(NULL, " "));
        
        // 如果命令是ls，则可能需要配置颜色
        if (myargv[0] != NULL && strcmp("ls", myargv[0]) == 0)
        {
            myargv[i - 1] = (char*)"--color=auto";
            myargv[i] = NULL;
        }

        // 如果命令是ll，则需要特殊处理一下
        if (myargv[0] != NULL && strcmp("ll", myargv[0]) == 0)
        {
            myargv[0][1] = 's';
            myargv[i - 1] = (char*)"--color=auto";
            myargv[i] = (char*)"-l";
            myargv[i + 1] = NULL;
        }

        // 如果命令是echo，则在当前进程就可以完成，为内建命令
        if (myargv[0] != NULL && myargv[1] != NULL && strcmp("echo", myargv[0]) == 0)
        {
            // 输出上一个进程的退出信息
            if (strcmp("$?", myargv[1]) == 0)
                printf("code:%d\tsig:%d\n", lastCode, lastSig);
            else 
                printf("%s\n", myargv[1]);
            continue;
        }

        // 如果命令是cd，则只能在当前进程完成，因为需要修改PWD - 当前路径
        if(myargv[0] != NULL && strcmp(myargv[0], "cd") == 0)
        {
            if(myargv[1] != NULL)
            {
                chdir(myargv[1]);
                strcpy(pwd, myargv[1]);
                get_path(pwd);
            }
            continue;
        }
        
        // 创建子进程进行进程替换
        pid_t id = fork();
        assert(id != -1);
        if (id == 0)
        {
            switch(redirType)
            {
                case NONE_REDIR:
                    break;
                case INPUT_REDIR:
                    {
                        // 先以只读的方式打开文件
                        int fd = open(redirFile, O_RDONLY);
                        if(fd < 0){
                            perror("open");
                            exit(errno);
                        }
                        // 输入重定向，改变文件描述符0的指向
                        dup2(fd, 0);
                    }
                    break;
                case OUTPUT_REDIR:
                case APPEND_REDIR:
                    {
                        umask(0);
                        // 无论是输入重定向还是输出重定向，都需要以写的方式打开文件
                        // 并且文件不存在时需要创建文件
                        int flags = O_WRONLY | O_CREAT;
                        // 如果是追加重定向，则添加要进行追加的信息
                        if(redirType == APPEND_REDIR) 
                            flags |= O_APPEND;
                        // 如果是输出重定向，则需要先清空文件
                        else 
                            flags |= O_TRUNC;
                        // 确定好打开文件的方式之后打开文件
                        int fd = open(redirFile, flags, 0666);
                        if(fd < 0)
                        {
                            perror("open");
                            exit(errno);
                        }
                        // 输出和追加都是像显示器输出或追加，所以需要改变文件描述符1的指向
                        dup2(fd, 1);
                    }
                    break;
            }

            execvp(myargv[0], myargv);
            exit(1);
        }
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        assert(ret > 0);
        (void)ret;
        lastCode = (status >> 8) & 0xFF;
        lastSig = status & 0x7F;
    }

    return 0;
}

这里需要想明白一件事，重定向并不会影响父进程，因为进程之间具有独立性。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/92735.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

http协议与apache

http协议与apache

http概念&#xff1a; 互联网&#xff1a;是网络的网络&#xff0c;是所有类型网络的母集 因特网&#xff1a;世界上最大的互联网网络。即因特网概念从属于互联网概念 万维网&#xff1a;万维网并非某种特殊的计算机网络&#xff0c;是一个大规模的、联机式的信息贮藏库&…
阅读更多...
SpringCloud Alibaba实战和源码（7）Skywalking

SpringCloud Alibaba实战和源码（7）Skywalking

什么是SkyWalking Skywalking是由国内开源爱好者吴晟开源并提交到Apache孵化器的产品&#xff0c;它同时吸收了Zipkin /Pinpoint /CAT 的设计思路。特点是&#xff1a;支持多种插件&#xff0c;UI功能较强&#xff0c;支持非侵入式埋点。目前使用厂商最多&#xff0c;版本更新较…
阅读更多...
keepalived+lvs+nginx高并发集群

keepalived+lvs+nginx高并发集群

keepalivedlvsnginx高并发集群 简介&#xff1a; keepalivedlvsnginx高并发集群&#xff0c;是通过LVS将请求流量均匀分发给nginx集群&#xff0c;而当单机nginx出现状态异常或宕机时&#xff0c;keepalived会主动切换并将不健康nginx下线&#xff0c;维持集群稳定高可用 1.L…
阅读更多...
【Java】Java基础

【Java】Java基础

环境准备 安装JDK和JRE 下载JDK&#xff0c;可以在官网Java Downloads | Oracle 中国下载&#xff0c;但是这里需要注册才能够下载。在Index of java-local/jdk (huaweicloud.com)也可以下载到&#xff0c;但是版本比较老&#xff0c;关系不大&#xff0c;直接下载&#xff0…
阅读更多...
node-red - 读写操作redis

node-red - 读写操作redis

node-red - 读写操作redis 一、前期准备二、node-red安装redis节点三、node-red操作使用redis节点3.1 redis-out节点 - 存储数据到redis3.2 redis-in节点 - 查询redis数据 附录附录1&#xff1a;redis -out节点示例代码附录2&#xff1a;redis -in节点示例代码 一、前期准备 安…
阅读更多...
On-Manifold Optimization: Local Parameterization

On-Manifold Optimization: Local Parameterization

Overview Manifold Space vs Tangent Space Jacobian w.r.t Error State Jacobian w.r.t Error State vs True State According 1 2.4, The idea is that for a x ∈ N x \in N x∈N the function g ( δ ) : f ( x ⊞ δ ) g(\delta) : f (x \boxplus \delta) g(δ):f(x…
阅读更多...
《C和指针》笔记10:作用域

《C和指针》笔记10:作用域

结合上面的例子讲解C语言的作用域。 1. 代码块作用域 (block scope) 位于一对花括号之间的所有语句称为一个代码块。任何在代码块的开始位置声明的标识符都具有代码块作用域 (block scope)&#xff0c;表示它们可以被这个代码块中的所有语句访问。上图中标识为6、7、9、10的变…
阅读更多...
视频云存储/安防监控视频智能分析网关V3：占道经营功能详解

视频云存储/安防监控视频智能分析网关V3：占道经营功能详解

违规占道经营者经常会在人流量大、车辆集中的道路两旁摆摊&#xff0c;导致公路交通堵塞&#xff0c;给居民出行的造成不便&#xff0c;而且违规占路密集的地方都是交通事故频频发生的区域。 TSINGSEE青犀视频云存储/安防监控视频/AI智能分析网关V3运用视频AI智能分析技术&…
阅读更多...
如何延长周末体验感

如何延长周末体验感

美好的周末永远都是从周五开始 为了享受周末的美好时光一定要在周五下班前把工作中应该处理的事情处理好&#xff0c;避免突发事件影响后续的计划。 此外过周五晚上开始做让自己感到开心的事情&#xff0c;以此让自己感觉到周末已经开始了。包括单不限于 享受美食 周五晚上是一…
阅读更多...
Java“牵手”天猫商品sku信息API接口数据，天猫API接口申请指南

Java“牵手”天猫商品sku信息API接口数据，天猫API接口申请指南

天猫平台商品sku属性信息接口是开放平台提供的一种API接口&#xff0c;通过调用API接口&#xff0c;开发者可以获取天猫商品的标题、价格、库存、月销量、总销量、库存、详情描述、图片等详细信息 。 获取商品销量接口API是一种用于获取电商平台上商品sku属性数据的接口&#…
阅读更多...
Linux系统：CentOS 7 CA证书服务器部署

Linux系统：CentOS 7 CA证书服务器部署

目录 一、理论 1.CA认证中心 2.CA证书服务器部署 二、实验 1. CA证书服务器部署 一、理论 1.CA认证中心 &#xff08;1&#xff09;概念 CA &#xff1a;CertificateAuthority的缩写&#xff0c;通常翻译成认证权威或者认证中心&#xff0c;主要用途是为用户发放数字证…
阅读更多...
Java线程 - 详解(1)

Java线程 - 详解(1)

一&#xff0c;创建线程 方法一&#xff1a;继承Thread类 class MyThread extends Thread{Overridepublic void run() {System.out.println("线程1");} }public class Test {public static void main(String[] args) {MyThread myThread new MyThread();myThread.…
阅读更多...
ChatGPT 与前端技术实现制作大屏可视化

ChatGPT 与前端技术实现制作大屏可视化

像这样的综合案例实分析，我们可以提供案例，维度与指标数据，让ChatGPT与AIGC 帮写出完整代码，并进行一个2行2列的布局设置。 数据与指令如下： 商品名称 销量 目标 完成率 可乐 479 600 79.83% 雪碧 324 600 54.00% 红茶 379 600 63.…
阅读更多...
LLMs NLP模型评估Model evaluation ROUGE and BLEU SCORE

LLMs NLP模型评估Model evaluation ROUGE and BLEU SCORE

在整个课程中&#xff0c;你看到过类似模型在这个任务上表现良好&#xff0c;或者这个微调模型在性能上相对于基础模型有显著提升等陈述。 这些陈述是什么意思&#xff1f;如何形式化你的微调模型在你起初的预训练模型上的性能改进&#xff1f;让我们探讨一些由大型语言模型开…
阅读更多...
httpd协议与apache

httpd协议与apache

1.http 相关概念 HTTP是处于应用层的协议&#xff0c;使用TCP传输层协议进行可靠的传送。因此&#xff0c;需要特别提醒的是&#xff0c;万维网是基于因特网的一种广泛因特网应用系统&#xff0c;且万维网采用的是HTTP&#xff08;80/TCP&#xff09;和 HTTPS&#xff08;443/…
阅读更多...
哔哩哔哩 B站 bilibili 视频视频音效调节 清澈人声

哔哩哔哩 B站 bilibili 视频视频音效调节 清澈人声

视频音效调节方式&#xff1a;直接视频播放内容界面内鼠标右键点击视频音效调节 注意&#xff1a;需要使用的是谷歌浏览器&#xff0c;我的火狐浏览器试了不行&#xff0c;都没选项&#xff0c;火狐的出来的界面是这样的&#xff1a; 目录 具体操作如下&#xff1a; 1、谷歌…
阅读更多...
第八章，帖子列表

第八章，帖子列表

8.1添加帖子列表 <script> import { mapState } from vuex . . . </script> computed: {...mapState([auth,user,articles]) }, <Message :sh
阅读更多...
mysql sql 执行流程

mysql sql 执行流程

监控查询缓存的命中率 show status like ‘%qcache%’; mysql 缓存机制&#xff0c;以及 8.0 为啥取消 select sql_NO_Cache * from 表 where xxx; # 不使用缓存
阅读更多...
（WAF）Web应用程序防火墙介绍

（WAF）Web应用程序防火墙介绍

&#xff08;WAF&#xff09;Web应用程序防火墙介绍 1. WAF概述 ​ Web应用程序防火墙&#xff08;WAF&#xff09;是一种关键的网络安全解决方案&#xff0c;用于保护Web应用程序免受各种网络攻击和威胁。随着互联网的不断发展&#xff0c;Web应用程序变得越来越复杂&#x…
阅读更多...
微服务集成spring cloud sentinel

微服务集成spring cloud sentinel

目录 1. sentinel使用场景 2. sentinel组成 3. sentinel dashboard搭建 4. sentinel客户端详细使用 4.1 引入依赖 4.2 application.properties增加dashboard注册地址 4.3 手动增加限流配置类 4.4 rest接口及service类 4.5 通过dashboard动态配置限流规则 1. sentinel使…
阅读更多...
最新文章

Copyright @ 2022~2023