Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇

前言

上一篇博客当中,我们对 文件 在操作系统当中是 如何就管理的,这个问题做了 详细描述,本篇博客将基于上篇 博客当中的内容进行 阐述,如有疑问,请参考上篇博客:

Linux - 基础IO(Linux 当中的文件,文件系统调用接口,文件描述符)- 上篇-CSDN博客

重定向

文件描述符的 分配规则

我们先来看一个例子:

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第1张图片

此时我们先 关闭 0 号文件,也就是 stdin 这个文件,然后在使用 open()系统调用接口来 创建一个新的文件,打印这个新文件的 fd 。输出:
 

发现新文件的 fd 文件描述符是 0,也就是原本的 stdin 这个文件描述符。


 同样,我们把 1 号文件 和 2 号文件都试一试,先是 1 号文件:
Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第2张图片

输出:

发现并没有输出,因为 printf()函数其中使用的系统调用接口就是 1 号文件的 stdout 这个流。

但其实,输出就是1 。

此时,其实是几输入到文件当中了的,只是当前的进程的 stdout 已经被关闭了,所以进程当中是无法使用 printf()函数打印出信息的:

 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第3张图片


 关闭 2 号文件:

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第4张图片

输出:
 

 发现,此时新打开的文件的文件描述符 fd 就是 开始关闭的 2 号文件。

所以,按照以上的 输出,其实我们已经可以得出结论了:

在 Linux 当中的文件描述符的分配规则是:


如果有新的文件要打开,那么就要为这个文件分配一个 新的 没有被其他文件使用过的 文件描述符 fd。

分配是按照 : 从 文件描述符表当中的 0 号下标位置处 开始,寻找最小的 还没有使用过的 数组位置,这个位置的下标就是新文件的 fd 文件描述符

 重定向理解 - 重定向的原理

像上述的,把 1 号文件 也就是 stdout 这个显示器文件 给关闭了, 所以我们使用printf()函数就是不能在显示器当中输出数据了。

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第5张图片

但是,上述也说过,虽然不会在 显示器当中输入, 但是会在 log.txt 这个新打开的文件当中,把原本应该输出在显示器当中的数据,写入到 log.txt 这个文件当中。

这是为什么呢?
其实看上述的代码你应该也知道了,因为 write()函数是固定像 1 号文件当中写入 数据,但是 1 号文件在 log.txt 这个新文件打开之前就被 关闭了。

也就是说,在 log.txt 这个新文件打开之前, 1 号 fd 文件描述符已经空闲下来了,所以, 新文件就会直接使用 1 号这个 fd 文件描述符。

所以,在后序循环当中 使用 write()函数在 1  号文件当中写入数据,实际是在 log.txt 当中写入数据。

其实,像上述的过程,就是一种重定向

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第6张图片

如上图所示,原本 1 号 文件描述符指向的是 显示器文件,但是现在指向的是 log.txt 这个文件了。

而这个变化的过程, 编译器在执行之时 ,也就是 while()循环当中的代码在执行之时,其实是不知道的,他只知道,现在要向 1 号文件当中写入 数据,但是它不知道 1 号文件,此时是 显示器文件 还是 log.txt 文件,还是其他什么文件,他是不知道的。

 而,上述的过程,就是重定向的 原理

 所以,在上图当中的  fd_array [] 数组当中的 每一个元素存储的是 文件对象的起始地址,修改 几号fd ,其实就是修改  fd_array [] 数组当中的 fd 下标位置的 文件对象的地址地址指针。

而,在代码层面,他不管他现在的任务是要在哪一个文件当中写入数据,这个文件在哪,这个文件的地址是多少,这些他都不关系;它只关心,这是几号文件,要在哪一个 fd 的文件的文件当中写入数据。

 重定向的系统调用接口

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第7张图片

有三个调用接口。我们主要来谈谈 dup2()这个函数:

 使用 dup2()函数,就可以不向上述一样显示的使用 close()函数来关闭文件,来实现重定向的 功能,直接使用这个 dup2()函数即可

使用 dup2()函数,就不用在关闭 1 号文件了当我们在 程序当中已经打开了 某一个文件,创建了这个文件的 文件描述符,那么在这个 文件描述符指向的 文件描述符表的 下标位置,就存储了这个文件的 文件对象的地址。

使用 dup2()函数,直接 把 某一个文件 在 文件描述符表当中存储的 文件对象的地址,直接拷贝到 需要重定向的 在 文件描述符表当中存储的 文件对象的地址 当中。如下图所示:

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第8张图片

  

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第9张图片


而 dup2()函数的两个参数:
 

在上述说过的拷贝的过程当中,谁是 "oldfd" , 谁是 "newfd" 呢?

在上述例子当中, 1 号文件是要被 fd 也就是 log,txt 文件对象地址所拷贝的,1 号 是 被拷贝;fd 是拷贝。

所以,在上述例子当中 1 号是  "newfd"; fd 是 "oldfd" 

dup2(fd , 1);

dup2() 接口例子测试

输出重定向 

 还是上述的例子,只不过,此时不使用 close()关闭文件来实现了,而是使用 dup2()函数来实现:
 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第10张图片

输出:
 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第11张图片

在原本是空的 log.txt 文件当中,在运行 text 可执行程序之后,log.txt 当中已经被写入了数据。

 现在的输出结果和上述 使用 close()关闭文件实现的效果是一样的 。

像上述我使用的是 O_TRUNC ,是先清空 文件当中的内容,然后在从头开始写入数据,对应的就是 ">" 这个输出重定向。

如果我们把 O_TRUNC  换成 O_APPEND,就是追加的方式来写入数据,对应的就是 ">>"这个输出重定向。


( 输入重定向) - 使用 read()系统调用接口 和 dup2()

其中的 count 是我们期望 read()函数读取多少个 字节的内容,返回值 ssize_t(这个是有符号整数) 是实际read()函数读取到多少字节的内容。写入到 buf 当中。

比如,count 期望大小我们填入 1024个字节,fd 文件我们选择 0 号 键盘文件,那么,他就会一直阻塞等待我们在键盘当中输入数据到缓冲区当中读取。

 在 open()函数当中,我们可以使用 O_RDONLT 这个参数,代表的意思就是 只读

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第12张图片

 输出:
 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第13张图片


 此时,我们使用read()函数在 log.txt 文件当中读取内容,在读取之前,使用 dup2()函数,把 0 号文件(也就是键盘文件 的 fd 值) ,直接替换为 log.txt 文件对象的地址:

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第14张图片

此时输出:
 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第15张图片

此时,运行程序,直接把文件当中的内容给输出出来了。 

 此时我们使用 O_RDONLT 这个参数,就实现了 "<" 输入重定向的操作。

这不就是cat命令吗?

直接使用 cat 命令,就可以等待 我们在键盘当中的输入,然后把输入内容打印出来:

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第16张图片

或者是 使用 "<" 来向文件当中,读取文件数据并打印:
 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第17张图片

 使用 printf()向文件当中写入数据

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第18张图片

在这个例子当中,我们把 1 号文件,利用 dup2()函数 把 1 号文件的文件指针修改为 log.txt 文件,此时,printf()函数 fprintf()就在  log.txt 文件当中写入数据了
 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第19张图片

在上述输出当中, 在显示器当中没有输出,但是在 log.txt 文件当中已经 有数据了。 

 所以,在上述,就算我们 close(fd),这个程序同样是会在 log.txt 文件当中的输入数据的,因为,此时 log.txt 文件对象的地址不只是 fd 保存的,还有 1 号文件描述符也是保存了 log.txt 的文件对象的地址。

而且,我们是在 1 号文件当中写入的 ,所以,是不会影响在log.txt 文件当中写入数据的。

 shell 当中的 输入/输出重定向 的实现 概述

 上述我们已经介绍了 输入/输出重定向 的简单实现,所以,在shell 当中,其实这些 输入/输出重定向 命令是属于 内建命令,直接在内建命令当中 判断 类似 ">>" ">" "<" 这样的字符子串,就可以判断,当前是不是 输入/输出重定向 的操作,就可以执行上述所实现的逻辑。

ls -a -l > myfile / ls -a -l >> myfile / cat < file.txt

 向上述的操作,我们可以发现,  ">>" ">" "<" 这样的字符子串 都是被空格 分隔开的,我们可以利用 之前在shell 模拟实现当中 分割字符串的操作,来提取出  ">>" ">" "<" 这样的字符子串。从而判断当前是不是  输入/输出重定向 操作。

(对于 shell 的模拟实现,参考这篇博客:Linux - 实现一个简单的 shell-CSDN博客)

其实做的工作非常简单:

在知道了上述的 重定向实现原理之后,其实我们只需要做判断即可:
 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第20张图片

比如上述判断 ">" 和 ">>" ,如果 当前的字符是 ">" 的话,如果下一个字符还是   ">" 的话,说明是 ">>" ,反之亦然;找到  ">" 或者 "<" 先把这两个字符修改为 '\0' 作为分割,因为 在 ">" 或者 "<" 之前的是 要输入或者要输出的数据,而在 ">" 或者 "<" 后面的是 文件名。

我们使用 isspace()函数来判断空格:

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第21张图片

 在空格之后就是我们想要的文件名。

找到之后,就要保存 两段的数据 命令 和 文件名

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第22张图片


在 shell 父进程 创建子进程的之后 马上  ,就要判断当前是否是 需要执行 重定向操作的(如果是,还有判断 是 哪一个重定向操作):

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第23张图片

如上所示,在判断 是哪一个重定向,然后就 按照对应的要求,修改 1 或者0 的其中一个 文件描述符值。

同时,文件打开方式也是区分 不同重定向操作的 步骤。0666 是 八进制 的 666 ,代表 用 open()函数创建的文件,是什么访问权限。(注意要减去 umack)

完整代码:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define LEFT "["
#define RIGHT "]"
#define LABLE "#"
#define DELIM " \t"
#define LINE_SIZE 1024
#define ARGC_SIZE 32
#define EXIT_CODE 44

#define NONE -1
#define IN_RDIR     0
#define OUT_RDIR    1
#define APPEND_RDIR 2

int lastcode = 0;
int quit = 0;
extern char** environ;
char commandline[LINE_SIZE];
char* argv[ARGC_SIZE];
char pwd[LINE_SIZE];
char* rdirfilename = NULL;
int rdir = NONE;

// 自定义环境变量表
char myenv[LINE_SIZE];
// 自定义本地变量表


const char* getusername()
{
    return getenv("USER");
}

const char* gethostname1()
{
    return getenv("HOSTNAME");
}

void getpwd()
{
    getcwd(pwd, sizeof(pwd));
}

void check_redir(char* cmd)
{

    // ls -al -n
    // ls -al -n >/> filename.txt
    char* pos = cmd;
    while (*pos)
    {
        if (*pos == '>') // 判断当前是 ">" ">>" 还是 "<"
        {
            if (*(pos + 1) == '>') {   // 判断当前是 ">" 还是 ">>" 
                *pos++ = '\0';
                *pos++ = '\0';
                while (isspace(*pos)) pos++;
                rdirfilename = pos;
                rdir = APPEND_RDIR;
                break;
            }
            else {      // 是 ">"          
                *pos = '\0';
                pos++;
                while (isspace(*pos)) pos++;
                rdirfilename = pos;
                rdir = OUT_RDIR;
                break;
            }
        }
        else if (*pos == '<')  // 是 "<"
        {
            *pos = '\0'; // ls -a -l -n < filename.txt
            pos++;
            while (isspace(*pos)) pos++;
            rdirfilename = pos;
            rdir = IN_RDIR;
            break;
        }
        else {
            //do nothing
        }
        pos++;
    }
}

void interact(char* cline, int size)
{
    getpwd();
    printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getusername(), gethostname1(), pwd);
    char* s = fgets(cline, size, stdin);
    assert(s);
    (void)s;
    // "abcd\n\0"
    cline[strlen(cline) - 1] = '\0';

    //ls -a -l > myfile.txt
    check_redir(cline);  // 在上述打印完 命令行,保存命令之后,用这个函数判断
                         // 命令当中是否有 重定向操作
}

int splitstring(char cline[], char* _argv[])
{
    int i = 0;
    argv[i++] = strtok(cline, DELIM);
    while (_argv[i++] = strtok(NULL, DELIM)); // 故意写的=
    return i - 1;
}

// 这个函数主要是实现 有 shell 父进程创建 子进程的过程
void NormalExcute(char* _argv[])
{
    pid_t id = fork();
    if (id < 0) {
        perror("fork");
        return;
    }
    else if (id == 0) {
        int fd = 0;

        // 判断当前子进程是否需要执行 重定向的工作
        if (rdir == IN_RDIR) // 执行输入重定向
        {
            fd = open(rdirfilename, O_RDONLY);
            dup2(fd, 0);
        }
        else if (rdir == OUT_RDIR) // 执行 ">" 
        {
            fd = open(rdirfilename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
            dup2(fd, 1);
        }
        else if (rdir == APPEND_RDIR)// 执行 ">>" 
        {
            fd = open(rdirfilename, O_CREAT | O_WRONLY | O_APPEND, 0666);
            dup2(fd, 1);
        }
        //让子进程执行命令
        //execvpe(_argv[0], _argv, environ);
        execvp(_argv[0], _argv);
        exit(EXIT_CODE);
    }
    else {
        int status = 0;
        pid_t rid = waitpid(id, &status, 0);
        if (rid == id)
        {
            lastcode = WEXITSTATUS(status);
        }
    }
}


// 这个函数当中是判断 和 实现一些内建命令的
int buildCommand(char* _argv[], int _argc)
{
    if (_argc == 2 && strcmp(_argv[0], "cd") == 0) {
        chdir(argv[1]);
        getpwd();
        sprintf(getenv("PWD"), "%s", pwd);
        return 1;
    }
    else if (_argc == 2 && strcmp(_argv[0], "export") == 0) {
        strcpy(myenv, _argv[1]);
        putenv(myenv);
        return 1;
    }
    else if (_argc == 2 && strcmp(_argv[0], "echo") == 0) {
        if (strcmp(_argv[1], "$?") == 0)
        {
            printf("%d\n", lastcode);
            lastcode = 0;
        }
        else if (*_argv[1] == '$') {
            char* val = getenv(_argv[1] + 1);
            if (val) printf("%s\n", val);
        }
        else {
            printf("%s\n", _argv[1]);
        }

        return 1;
    }

    // 特殊处理一下ls
    if (strcmp(_argv[0], "ls") == 0)
    {
        _argv[_argc++] = "--color";
        _argv[_argc] = NULL;
    }
    return 0;
}

int main()
{
    while (!quit) {
        // 1.rdirfilename 用于保存文件名, rdir 保存要输入/输出的数据方式(命令)
        rdirfilename = NULL;
        rdir = NONE;
        // 2. 交互问题,获取命令行, ls -a -l > myfile / ls -a -l >> myfile / cat < file.txt
        interact(commandline, sizeof(commandline));

        // commandline -> "ls -a -l -n\0" -> "ls" "-a" "-l" "-n"
        // 3. 子串分割的问题,解析命令行
        int argc = splitstring(commandline, argv);
        if (argc == 0) continue;

        // 4. 指令的判断 
        // debug
        //for(int i = 0; argv[i]; i++) printf("[%d]: %s\n", i, argv[i]);
        //内键命令,本质就是一个shell内部的一个函数
        int n = buildCommand(argv, argc);

        // 5. 普通命令的执行
        if (!n) NormalExcute(argv);
    }
    return 0;
}

shell 当中的 输入/输出重定向  和 进程替换之间的关系

 不知道你有没有发现,我们在 check_redir()函数当中判断,是否需要重定向操作,然后修改对应存储 重定向操作符前后的 命令 和 文件名。

用这两个 存储 重定向操作符前后的 命令 和 文件名 的两个全局变量的值,在 shell 父进程创建子进程 之后 马上,判断当前是否需要执行 重定向的操作。

 但是,如果需要执行重定向,那么 在 修改 文件描述符值 之后,说明此时是在 子进程 当中修改的 文件描述符值。

然后我们要进行程序替换,让子进程执行我们在命令行当中输入的命令。

 那么,在执行 程序替换之时不会替换掉 这些文件描述符表 当中存储的文件对象的地址么吗?

 答案是不会的

首先你要搞清楚的是,一个进程的 各个文件描述符值 是存储在那里的?

  是存储在 struct file_struct 这个结构体 当中的,在这个结构体当中有一个数组,这个数组 就被称作 -- 文件描述符表。在这个数组当中就存储了 这个进程当前所 打开的 各个文件的  文件对象的地址

所以,这是一个机构体,是被 操作系统做管理的结构体对象,所以这个 struct file_struct 这个结构体  和 进程 的 PCB对象一样,都属于 操作系统当中的 内核结构体

而 , 我们进行程序替换,替换的是 代码 数据,把 原本子进程 从 父进程那里拷贝或者共用的代码,进行直接拷贝 或者 写时拷贝的方式,替换为 我们在命令行当中输入 的命令的 代码,而数据也是跟着一起刷新的。

那么 这些 代码 和 数据是存储在哪里的?是存储在 内存的物理空间当中的,要注意区分。

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第24张图片

 所以,进程历史打开的所有文件,都在 struct file_struct 这个结构体 当中的 特定数组当中存储了 文件描述符,程序替换不会修改到这个 结构体,所以,程序替换 和 fd 文件描述符 无关

 所以,我们上述在实现之时,才是先把重定向的工作做了,再去程序替换;这样,重定向当中要修改的 文件描述符,和 进程替换无关,那么就不会被修改到。

而且,我们判断 是否需要重定向 的 两个全局变量是在父进程当中存储的,是在创建子进程之前就 已经 完成判断了的,这些数据,在进行程序替换之时都会被替换掉。

 stdout 和 stderr 是区别

 其实两个都是 显示器文件,都是输出重定向来使用的。

两者我们发现,使用 fprintf()函数都可以在 屏幕上打印 数据。

但是,之所以要 使用 两个显示器文件是因为,一个是 normal 正常的 数据输出;另一个 是 error 错误码输出;他想做到一种分流的 作用,把 正常的数据 和 错误的数据分成种方式输出。

为什么呢?

别忘了,输出不仅仅是在 显示器上输出,还可以在 文件当中输出。

所以,可以用两个文件,一个存储 正常的输出数据,一个存储错误输出数据;而我们在使用两种显示器文件输出数据之时,就可以在两个文件当中进程输出不同的数据了。


比如,此时有些 正常数据 和 一些错误的数据要输出:

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第25张图片

那么,我们可以使用不同的 显示器文件来 输出,达到分流的目的:
 

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第26张图片

 上述这个命令,就是把 mytext 执行文件的输出结果,把 1 号文件的内容输出重定向到 normal.log 当中;把 2 号文件当中的内容 输出重定向到 arr.log 当中。(其中 1 可以不写(这些简写)

这样在两个文件当中就是不同 输出内容了。

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第27张图片

 像这样是 先把 1 号文件文件描述符 对应的 文件 当中的内容输入到 all.log 当中,然后把 1 号文件描述符当中的内容写到 2 号文件描述符值当中(2>&1)

 注意,是直接把 1 号文件描述符当中的内容,拷贝到 2 号文件描述符当中,1 号文件描述符当中的内容就是 1 号文件描述符 对应 的文件的 地址。所以,是直接把 1 号文件地址 直接 拷贝到 了 2 号文件描述符当中,相当于是 dup2()函数一样。

Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇_第28张图片

你可能感兴趣的:(linux,运维,服务器)