Question

是否有可移植的方式（POSIX）来获取当前进程的最高分配文件描述符号？

我知道有一种很好的方法可以在AIX上获取数字，例如，我正在寻找一种可移植的方法。

我问的原因是我要关闭所有打开的文件描述符。我的程序是一个以root用户身份运行的服务器，为非root用户分叉和执行子程序。在子进程中保留特权文件描述符是一个安全问题。有些文件描述符可能是由我无法控制的代码（C库，第三方库等）打开的，所以我也不能依赖FD_CLOEXEC。

Answer 1

虽然是可移植的，但是关闭所有文件描述符直到sysconf(_SC_OPEN_MAX)是不可靠的，因为在大多数系统上，此调用返回当前文件描述符软限制，该限制可能已降低到最高使用文件描述符之下。另一个问题是，在许多系统sysconf(_SC_OPEN_MAX)上可能会返回INT_MAX，这可能导致此方法变得无法接受。不幸的是，没有可靠的，可移植的替代方案，不涉及迭代每个可能的非负int文件描述符。

虽然不可移植，但目前常用的大多数操作系统都为此问题提供了以下一种或多种解决方案：

关闭所有文件描述符的库函数＆gt; = fd 。对于关闭所有文件描述符的常见情况，这是最简单的解决方案，尽管它不能用于其他许多方面。要关闭除某个集合之外的所有文件描述符，可以使用dup2预先将它们移动到低端，并在必要时将其移回。
- closefrom(fd)（Solaris 9或更高版本，FreeBSD 7.3或8.0及更高版本，NetBSD 3.0或更高版本，OpenBSD 3.5或更高版本。）
- fcntl(fd, F_CLOSEM, 0)（AIX，IRIX，NetBSD）
提供当前正由进程使用的最大文件描述符的库函数。要关闭某个数字以上的所有文件描述符，要么将所有文件描述符关闭到最大值，要么在循环中连续获取和关闭最高文件描述符，直到达到下限。哪个更有效取决于文件描述符密度。
- fcntl(0, F_MAXFD)（NetBSD）
- pstat_getproc(&ps, sizeof(struct pst_status), (size_t)0, (int)getpid())
  返回有关进程的信息，包括ps.pst_highestfd中当前打开的最高文件描述符。（HP-UX）
目录，其中包含每个打开文件描述符的条目。这是最灵活的方法，因为它允许关闭所有文件描述符，查找最高文件描述符，或者对每个打开的文件描述符执行任何其他操作，甚至是其他进程（在大多数系统上）。然而，这可能比常用的其他方法更复杂。此外，它可能由于各种原因而失败，例如未安装proc / fdescfs，chroot环境或没有可用于打开目录的文件描述符（进程或系统限制）。因此，这种方法的使用通常与回退机制相结合。 Example (OpenSSH)，another example (glib)。
- /proc/ pid /fd/或/proc/self/fd/（Linux，Solaris，AIX，Cygwin，NetBSD）
  （AIX不支持“self”）
- /dev/fd/（FreeBSD，Darwin，OS X）
使用这种方法可以很难可靠地处理所有角落情况。例如，考虑要关闭所有文件描述符＆gt; = fd 的情况，但是所有文件描述符＆lt;使用 fd ，当前进程资源限制为 fd ，并且正在使用文件描述符＆gt; = fd 。由于已达到进程资源限制，因此无法打开目录。如果通过资源限制从 fd 关闭每个文件描述符或sysconf(_SC_OPEN_MAX)用作后备，则不会关闭任何内容。

Answer 2

POSIX方式是：

int maxfd=sysconf(_SC_OPEN_MAX);
for(int fd=3; fd<maxfd; fd++)
    close(fd);

（请注意，从3开始关闭，以保持stdin / stdout / stderr打开）

如果文件描述符未打开，

close（）将无害地返回EBADF。没有必要浪费其他系统调用检查。

有些Unix支持closefrom（）。这可以避免对close（）的过多调用，具体取决于最大可能的文件描述符编号。虽然我知道最好的解决方案，但它完全不可移植。

Answer 3

我编写了代码来处理所有特定于平台的功能。所有功能都是异步信号安全的。以为人们可能会觉得这很有用。现在只在OS X上测试，随时改进/修复。

// Async-signal safe way to get the current process's hard file descriptor limit.
static int
getFileDescriptorLimit() {
    long long sysconfResult = sysconf(_SC_OPEN_MAX);

    struct rlimit rl;
    long long rlimitResult;
    if (getrlimit(RLIMIT_NOFILE, &rl) == -1) {
        rlimitResult = 0;
    } else {
        rlimitResult = (long long) rl.rlim_max;
    }

    long result;
    if (sysconfResult > rlimitResult) {
        result = sysconfResult;
    } else {
        result = rlimitResult;
    }
    if (result < 0) {
        // Both calls returned errors.
        result = 9999;
    } else if (result < 2) {
        // The calls reported broken values.
        result = 2;
    }
    return result;
}

// Async-signal safe function to get the highest file
// descriptor that the process is currently using.
// See also http://stackoverflow.com/questions/899038/getting-the-highest-allocated-file-descriptor
static int
getHighestFileDescriptor() {
#if defined(F_MAXFD)
    int ret;

    do {
        ret = fcntl(0, F_MAXFD);
    } while (ret == -1 && errno == EINTR);
    if (ret == -1) {
        ret = getFileDescriptorLimit();
    }
    return ret;

#else
    int p[2], ret, flags;
    pid_t pid = -1;
    int result = -1;

    /* Since opendir() may not be async signal safe and thus may lock up
     * or crash, we use it in a child process which we kill if we notice
     * that things are going wrong.
     */

    // Make a pipe.
    p[0] = p[1] = -1;
    do {
        ret = pipe(p);
    } while (ret == -1 && errno == EINTR);
    if (ret == -1) {
        goto done;
    }

    // Make the read side non-blocking.
    do {
        flags = fcntl(p[0], F_GETFL);
    } while (flags == -1 && errno == EINTR);
    if (flags == -1) {
        goto done;
    }
    do {
        fcntl(p[0], F_SETFL, flags | O_NONBLOCK);
    } while (ret == -1 && errno == EINTR);
    if (ret == -1) {
        goto done;
    }

    do {
        pid = fork();
    } while (pid == -1 && errno == EINTR);

    if (pid == 0) {
        // Don't close p[0] here or it might affect the result.

        resetSignalHandlersAndMask();

        struct sigaction action;
        action.sa_handler = _exit;
        action.sa_flags   = SA_RESTART;
        sigemptyset(&action.sa_mask);
        sigaction(SIGSEGV, &action, NULL);
        sigaction(SIGPIPE, &action, NULL);
        sigaction(SIGBUS, &action, NULL);
        sigaction(SIGILL, &action, NULL);
        sigaction(SIGFPE, &action, NULL);
        sigaction(SIGABRT, &action, NULL);

        DIR *dir = NULL;
        #ifdef __APPLE__
            /* /dev/fd can always be trusted on OS X. */
            dir = opendir("/dev/fd");
        #else
            /* On FreeBSD and possibly other operating systems, /dev/fd only
             * works if fdescfs is mounted. If it isn't mounted then /dev/fd
             * still exists but always returns [0, 1, 2] and thus can't be
             * trusted. If /dev and /dev/fd are on different filesystems
             * then that probably means fdescfs is mounted.
             */
            struct stat dirbuf1, dirbuf2;
            if (stat("/dev", &dirbuf1) == -1
             || stat("/dev/fd", &dirbuf2) == -1) {
                _exit(1);
            }
            if (dirbuf1.st_dev != dirbuf2.st_dev) {
                dir = opendir("/dev/fd");
            }
        #endif
        if (dir == NULL) {
            dir = opendir("/proc/self/fd");
            if (dir == NULL) {
                _exit(1);
            }
        }

        struct dirent *ent;
        union {
            int highest;
            char data[sizeof(int)];
        } u;
        u.highest = -1;

        while ((ent = readdir(dir)) != NULL) {
            if (ent->d_name[0] != '.') {
                int number = atoi(ent->d_name);
                if (number > u.highest) {
                    u.highest = number;
                }
            }
        }
        if (u.highest != -1) {
            ssize_t ret, written = 0;
            do {
                ret = write(p[1], u.data + written, sizeof(int) - written);
                if (ret == -1) {
                    _exit(1);
                }
                written += ret;
            } while (written < (ssize_t) sizeof(int));
        }
        closedir(dir);
        _exit(0);

    } else if (pid == -1) {
        goto done;

    } else {
        do {
            ret = close(p[1]);
        } while (ret == -1 && errno == EINTR);
        p[1] = -1;

        union {
            int highest;
            char data[sizeof(int)];
        } u;
        ssize_t ret, bytesRead = 0;
        struct pollfd pfd;
        pfd.fd = p[0];
        pfd.events = POLLIN;

        do {
            do {
                // The child process must finish within 30 ms, otherwise
                // we might as well query sysconf.
                ret = poll(&pfd, 1, 30);
            } while (ret == -1 && errno == EINTR);
            if (ret <= 0) {
                goto done;
            }

            do {
                ret = read(p[0], u.data + bytesRead, sizeof(int) - bytesRead);
            } while (ret == -1 && ret == EINTR);
            if (ret == -1) {
                if (errno != EAGAIN) {
                    goto done;
                }
            } else if (ret == 0) {
                goto done;
            } else {
                bytesRead += ret;
            }
        } while (bytesRead < (ssize_t) sizeof(int));

        result = u.highest;
        goto done;
    }

done:
    if (p[0] != -1) {
        do {
            ret = close(p[0]);
        } while (ret == -1 && errno == EINTR);
    }
    if (p[1] != -1) {
        do {
            close(p[1]);
        } while (ret == -1 && errno == EINTR);
    }
    if (pid != -1) {
        do {
            ret = kill(pid, SIGKILL);
        } while (ret == -1 && errno == EINTR);
        do {
            ret = waitpid(pid, NULL, 0);
        } while (ret == -1 && errno == EINTR);
    }

    if (result == -1) {
        result = getFileDescriptorLimit();
    }
    return result;
#endif
}

void
closeAllFileDescriptors(int lastToKeepOpen) {
    #if defined(F_CLOSEM)
        int ret;
        do {
            ret = fcntl(lastToKeepOpen + 1, F_CLOSEM);
        } while (ret == -1 && errno == EINTR);
        if (ret != -1) {
            return;
        }
    #elif defined(HAS_CLOSEFROM)
        closefrom(lastToKeepOpen + 1);
        return;
    #endif

    for (int i = getHighestFileDescriptor(); i > lastToKeepOpen; i--) {
        int ret;
        do {
            ret = close(i);
        } while (ret == -1 && errno == EINTR);
    }
}

Answer 4

当你的程序启动并且没有打开任何东西时。例如。喜欢main（）的开头。管道和fork立即启动执行器服务器。这样它的内存和其他细节都很干净，你可以把它放到fork＆amp; EXEC键。

#include <unistd.h>
#include <stdio.h>
#include <memory.h>
#include <stdlib.h>

struct PipeStreamHandles {
    /** Write to this */
    int output;
    /** Read from this */
    int input;

    /** true if this process is the child after a fork */
    bool isChild;
    pid_t childProcessId;
};

PipeStreamHandles forkFullDuplex(){
    int childInput[2];
    int childOutput[2];

    pipe(childInput);
    pipe(childOutput);

    pid_t pid = fork();
    PipeStreamHandles streams;
    if(pid == 0){
        // child
        close(childInput[1]);
        close(childOutput[0]);

        streams.output = childOutput[1];
        streams.input = childInput[0];
        streams.isChild = true;
        streams.childProcessId = getpid();
    } else {
        close(childInput[0]);
        close(childOutput[1]);

        streams.output = childInput[1];
        streams.input = childOutput[0];
        streams.isChild = false;
        streams.childProcessId = pid;
    }

    return streams;
}


struct ExecuteData {
    char command[2048];
    bool shouldExit;
};

ExecuteData getCommand() {
    // maybe use json or semething to read what to execute
    // environment if any and etc..        
    // you can read via stdin because of the dup setup we did
    // in setupExecutor
    ExecuteData data;
    memset(&data, 0, sizeof(data));
    data.shouldExit = fgets(data.command, 2047, stdin) == NULL;
    return data;
}

void executorServer(){

    while(true){
        printf("executor server waiting for command\n");
        // maybe use json or semething to read what to execute
        // environment if any and etc..        
        ExecuteData command = getCommand();
        // one way is for getCommand() to check if stdin is gone
        // that way you can set shouldExit to true
        if(command.shouldExit){
            break;
        }
        printf("executor server doing command %s", command.command);
        system(command.command);
        // free command resources.
    }
}

static PipeStreamHandles executorStreams;
void setupExecutor(){
    PipeStreamHandles handles = forkFullDuplex();

    if(handles.isChild){
        // This simplifies so we can just use standard IO 
        dup2(handles.input, 0);
        // we comment this out so we see output.
        // dup2(handles.output, 1);
        close(handles.input);
        // we uncomment this one so we can see hello world
        // if you want to capture the output you will want this.
        //close(handles.output);
        handles.input = 0;
        handles.output = 1;
        printf("started child\n");
        executorServer();
        printf("exiting executor\n");
        exit(0);
    }

    executorStreams = handles;
}

/** Only has 0, 1, 2 file descriptiors open */
pid_t cleanForkAndExecute(const char *command) {
    // You can do json and use a json parser might be better
    // so you can pass other data like environment perhaps.
    // and also be able to return details like new proccess id so you can
    // wait if it's done and ask other relevant questions.
    write(executorStreams.output, command, strlen(command));
    write(executorStreams.output, "\n", 1);
}

int main () {
    // needs to be done early so future fds do not get open
    setupExecutor();

    // run your program as usual.
    cleanForkAndExecute("echo hello world");
    sleep(3);
}

如果你想在执行的程序上执行IO，执行程序服务器必须执行套接字重定向，你可以使用unix套接字。

Answer 5

在 MacOS 上，您可以将 posix_spawn 与使用 POSIX_SPAWN_CLOEXEC_DEFAULT 设置的 Apple 扩展 posix_spawnattr_setflags 一起使用。

这将只保留在 posix_spawn 调用中明确设置的文件描述符打开，其他调用关闭。

Answer 6

为什么不关闭从0到10000的所有描述符。

它会很快，最糟糕的事情就是EBADF。

获得分配最高的文件描述符

6 个答案: