在STDOUT和STDIN的文件描述符上执行库函数的奇怪行为

Question

在我作为C程序员的这些年里,我一直对标准流文件描述符感到困惑.有些地方,比如维基百科^[1],说:

在C编程语言中,标准输入,输出和错误流分别附加到现有的Unix文件描述符0,1和2.

这有以下支持unistd.h:

/* Standard file descriptors.  */
#define STDIN_FILENO    0       /* Standard input.  */
#define STDOUT_FILENO   1       /* Standard output.  */
#define STDERR_FILENO   2       /* Standard error output.  */

但是,这段代码(在任何系统上):

write(0, "Hello, World!\n", 14);

将打印Hello, World!(和换行)STDOUT.这很奇怪,因为STDOUT文件描述符应该是write1.-文件描述符1也打印到STDOUT.

执行ioctl文件描述符0改变标准输入^[2],文件描述符1改变标准输出.但是,在0或1上执行termios功能会改变标准输入^{[3] [4]}.

我对文件描述符1和0的行为非常困惑.有谁知道原因:

• write写入1或0写入标准输出？
• 执行ioctl1修改标准输出,0修改标准输入,但执行tcsetattr/ tcgetattron 1或0适用于标准输入？

Answer 1

我想这是因为我在Linux下,0并且1在默认情况下打开与读/写的/dev/tty是哪个进程的控制终端.所以确实甚至可以从中读取stdout.

然而,这一旦打破,你管的东西或缩小:

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

int main() {
    errno = 0;
    write(0, "Hello world!\n", 14);
    perror("write");
}

并运行

% ./a.out 
Hello world!
write: Success
% echo | ./a.out
write: Bad file descriptor

termios函数总是实际的底层终端物体上工作,所以也没关系是否0或1用于只要它被打开到终端.

Answer 2

让我们首先回顾一下涉及的一些关键概念：

• 文件描述

  在操作系统内核中，每个文件、管道端点、套接字端点、打开设备节点等，都有一个文件描述。内核使用它们来跟踪文件中的位置、标志（读、写、追加、执行时关闭）、记录锁等。

  文件描述是内核内部的，并且不属于任何特定进程（在典型实现中）。
   

• 文件描述符

  从进程的角度来看，文件描述符是标识打开的文件、管道、套接字、FIFO 或设备的整数。

  操作系统内核为每个进程保留一个描述符表。进程使用的文件描述符只是该表的索引。

  文件描述符表中的条目指的是内核文件描述。

每当进程使用dup()或dup2()复制文件描述符时，内核仅复制该进程的文件描述符表中的条目；它不会复制它自己保留的文件描述。

当进程分叉时，子进程获得自己的文件描述符表，但条目仍然指向完全相同的内核文件描述。（这本质上是浅复制，所有文件描述符表条目都是对文件描述的引用。引用被复制；引用的目标保持不变。）

当一个进程通过 Unix 域套接字辅助消息向另一个进程发送文件描述符时，内核实际上在接收者上分配一个新的描述符，并复制所传输的描述符所引用的文件描述。

一切都运行得很好，尽管“文件描述符”和“文件描述”如此相似有点令人困惑。

这一切与OP所看到的效果有什么关系？

每当创建新进程时，通常都会打开目标设备、管道或套接字以及dup2()标准输入、标准输出和标准错误的描述符。这导致所有三个标准描述符都引用相同的文件描述，因此使用一个文件描述符有效的任何操作，使用其他文件描述符也有效。

当在控制台上运行程序时，这是最常见的，因为这三个描述符肯定都引用相同的文件描述；该文件描述描述了伪终端字符设备的从端。

考虑以下程序run.c：

#define  _POSIX_C_SOURCE 200809L
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

static void wrerrp(const char *p, const char *q)
{
    while (p < q) {
        ssize_t  n = write(STDERR_FILENO, p, (size_t)(q - p));
        if (n > 0)
            p += n;
        else
            return;
    }
}

static inline void wrerr(const char *s)
{
    if (s)
        wrerrp(s, s + strlen(s));
}

int main(int argc, char *argv[])
{
    int fd;

    if (argc < 3) {
        wrerr("\nUsage: ");
        wrerr(argv[0]);
        wrerr(" FILE-OR-DEVICE COMMAND [ ARGS ... ]\n\n");
        return 127;
    }

    fd = open(argv[1], O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        const char *msg = strerror(errno);
        wrerr(argv[1]);
        wrerr(": Cannot open file: ");
        wrerr(msg);
        wrerr(".\n");
        return 127;
    }

    if (dup2(fd, STDIN_FILENO) != STDIN_FILENO ||
        dup2(fd, STDOUT_FILENO) != STDOUT_FILENO) {
        const char *msg = strerror(errno);
        wrerr("Cannot duplicate file descriptors: ");
        wrerr(msg);
        wrerr(".\n");
        return 126;
    }
    if (dup2(fd, STDERR_FILENO) != STDERR_FILENO) {
        /* We might not have standard error anymore.. */
        return 126;
    }

    /* Close fd, since it is no longer needed. */
    if (fd != STDIN_FILENO && fd != STDOUT_FILENO && fd != STDERR_FILENO)
        close(fd);

    /* Execute the command. */
    if (strchr(argv[2], '/'))
        execv(argv[2], argv + 2);  /* Command has /, so it is a path */
    else
        execvp(argv[2], argv + 2); /* command has no /, so it is a filename */

    /* Whoops; failed. But we have no stderr left.. */
    return 125;
}

它需要两个或多个参数。第一个参数是文件或设备，第二个参数是命令，其余参数提供给命令。运行该命令，所有三个标准描述符都重定向到第一个参数中指定的文件或设备。您可以使用 gcc 编译上面的内容，例如

gcc -Wall -O2 run.c -o run

让我们编写一个小型测试器实用程序，report.c：

#define  _POSIX_C_SOURCE 200809L
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    char    buffer[16] = { "\n" };
    ssize_t result;
    FILE   *out;

    if (argc != 2) {
        fprintf(stderr, "\nUsage: %s FILENAME\n\n", argv[0]);
        return EXIT_FAILURE;
    }

    out = fopen(argv[1], "w");
    if (!out)
        return EXIT_FAILURE;

    result = write(STDIN_FILENO, buffer, 1);
    if (result == -1) {
        const int err = errno;
        fprintf(out, "write(STDIN_FILENO, buffer, 1) = -1, errno = %d (%s).\n", err, strerror(err));
    } else {
        fprintf(out, "write(STDIN_FILENO, buffer, 1) = %zd%s\n", result, (result == 1) ? ", success" : "");
    }

    result = read(STDOUT_FILENO, buffer, 1);
    if (result == -1) {
        const int err = errno;
        fprintf(out, "read(STDOUT_FILENO, buffer, 1) = -1, errno = %d (%s).\n", err, strerror(err));
    } else {
        fprintf(out, "read(STDOUT_FILENO, buffer, 1) = %zd%s\n", result, (result == 1) ? ", success" : "");
    }

    result = read(STDERR_FILENO, buffer, 1);
    if (result == -1) {
        const int err = errno;
        fprintf(out, "read(STDERR_FILENO, buffer, 1) = -1, errno = %d (%s).\n", err, strerror(err));
    } else {
        fprintf(out, "read(STDERR_FILENO, buffer, 1) = %zd%s\n", result, (result == 1) ? ", success" : "");
    }

    if (ferror(out))
        return EXIT_FAILURE;
    if (fclose(out))
        return EXIT_FAILURE;

    return EXIT_SUCCESS;
}

它仅需要一个参数（要写入的文件或设备）来报告是否写入标准输入、从标准输出读取以及错误工作。（我们通常可以$(tty)在 Bash 和 POSIX shell 中使用，以引用实际的终端设备，以便报告在终端上可见。）使用例如编译此报告

gcc -Wall -O2 report.c -o report

现在，我们可以检查一些设备：

./run /dev/null    ./report $(tty)
./run /dev/zero    ./report $(tty)
./run /dev/urandom ./report $(tty)

或任何我们想要的。在我的机器上，当我在文件上运行它时，比如说

./run some-file ./report $(tty)

写入标准输入、读取标准输出和标准错误都可以工作——这是预期的，因为文件描述符引用相同的、可读和可写的文件描述。

经过上述分析后得出的结论是，这里根本没有任何奇怪的行为。如果进程使用的文件描述符只是对操作系统内部文件描述的引用，并且标准输入、输出和错误描述符dup彼此重复，那么这一切的行为就完全符合人们的预期。