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的文件描述符应该是1. write - 文件描述符1 也打印到STDOUT。

对文件描述符0执行ioctl会更改标准输入^[2]，并且文件描述符1会更改标准输出。但是，对0或1执行termios functions会更改标准输入^{[3] [4]}。

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

write 1或0写入标准输出？
在1上执行ioctl修改标准输出，在0上修改标准输入，但在1或0上执行tcsetattr / tcgetattr适用于标准输入？

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打开到tty就无关紧要

Answer 2

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

文件说明

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

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

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

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

文件描述符表中的条目引用内核文件描述。

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

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

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

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

所有这些与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;
}

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

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互相许可。

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

2 个答案: