Den höchsten zugewiesenen Dateideskriptor erhalten

Gibt es eine portable Art und Weise (POSIX), um den höchsten zugewiesenen Datei-Deskriptor-Nummer für den aktuellen Prozess?

Ich weiß, dass es ein netter Weg, um die Anzahl auf AIX, zum Beispiel, aber ich bin auf der Suche nach einem tragbaren Methode.

Den Grund ich Frage ist, dass ich möchte, um zu schließen Sie alle geöffneten Datei-Deskriptoren. Mein Programm ist ein server, der als root läuft und die Gabeln und die execs Kind-Programme für nicht-root-Benutzer. Verlassen der privilegierten Dateideskriptoren geöffnet in der Kind-Prozess ist ein Sicherheits-problem. Einige Dateideskriptoren geöffnet werden kann durch den code, den ich nicht kontrollieren kann (die C-Bibliothek, Bibliotheken von Drittanbietern, etc.), so kann ich nicht verlassen sich auf FD_CLOEXEC.

InformationsquelleAutor der Frage Ville Laurikari | 2009-05-22

file-descriptor posix

62

Während portable, schließen Sie alle Datei-Deskriptoren, bis zu sysconf(_SC_OPEN_MAX) ist nicht zuverlässig, weil auf den meisten Systemen dieser Aufruf liefert die aktuelle Datei-Deskriptor weiche Grenze, die hätten abgesenkt unterhalb der höchsten verwendeten Datei-Deskriptors. Ein weiteres Problem ist, dass auf vielen Systemen sysconf(_SC_OPEN_MAX) zurückgeben kann INT_MAXdie dazu führen können, dass dieser Ansatz sehr langsam. Leider gibt es keine zuverlässige, portable alternative, die nicht die Iteration über alle möglichen nicht-negativen int Datei-Deskriptor.

Obwohl nicht tragbar, meisten Betriebssystemen gemeinsam nutzen, stellen heute eine oder mehrere der folgenden Lösungen für dieses problem:
1. Einer library-Funktion, um schließen Sie alle Datei-Deskriptoren >= fd. Dies ist die einfachste Lösung für den Allgemeinen Fall zu schließen, alle Datei-Deskriptoren, obwohl es nicht verwendet werden kann für viel mehr. Schließen Sie alle Datei-Deskriptoren, außer für eine bestimmte Gruppe, dup2 verwendet werden können, um Sie zu bewegen, um die low-end-vorher, und verschieben Sie Sie zurück später, wenn nötig.
  - closefrom(fd) (Solaris 9 oder höher, FreeBSD 7.3 oder 8.0 und höher, NetBSD-3.0 oder höher, OpenBSD 3.5 oder höher).
  - fcntl(fd, F_CLOSEM, 0) (AIX, IRIX, NetBSD)
2. Einer library-Funktion zu bieten, die maximale Datei-Deskriptor derzeit in Verwendung durch den Prozess. Schließen Sie alle Datei-Deskriptoren, die über eine bestimmte Anzahl, entweder schließen Sie alle von Ihnen bis zu diesem maximum, oder kontinuierlich, und schließen Sie die höchste file-descriptor in einer Schleife, bis die niedrige Grenze erreicht. Was effizienter ist, hängt von der Datei-Deskriptor-Dichte.
  - fcntl(0, F_MAXFD) (NetBSD)
  - pstat_getproc(&ps, sizeof(struct pst_status), (size_t)0, (int)getpid())
    
    Gibt Informationen über den Prozess, einschließlich der höchsten file-Deskriptor die aktuell in ps.pst_highestfd. (HP-UX)
3. Einen Verzeichnis enthält einen Eintrag für jedes offene file-Deskriptor. Dies ist der flexibelste Ansatz, da Sie ermöglicht für schließen Sie alle Datei-Deskriptoren, finden die höchste Datei-Deskriptor, oder tun irgendetwas anderes, auf jedem open-file-Deskriptor, sogar jene, die von einem anderen Prozess (auf den meisten Systemen). Dies kann jedoch komplizierter sein als die anderen Ansätze für die gemeinsame Nutzung. Auch, es kann fehlschlagen, für eine Vielzahl von Gründen, wie die/proc /fdescfs nicht montiert ist, eine chroot-Umgebung, oder keine Datei-Deskriptoren verfügbar sind, öffnen Sie das Verzeichnis (Prozess-oder system-Grenze). Daher ist die Nutzung dieser Ansatz wird oft in Kombination mit einem fallback-Mechanismus. Beispiel (OpenSSH)ein weiteres Beispiel (glib).
  - /proc/pid/fd/ oder /proc/self/fd/ (Linux, Solaris, AIX, Cygwin, NetBSD)
    
    (AIX nicht unterstützt "self")
  - /dev/fd/ (FreeBSD, Darwin, OS X)
  Kann es schwierig sein, um alle Ecke Fälle zuverlässig mit diesem Ansatz. Zum Beispiel betrachten die situation, wo alle Datei-Deskriptoren >= fd geschlossen werden, aber alle file-Deskriptoren < fd verwendet werden, den aktuellen Prozess-Ressourcen-limit ist fdund es gibt Datei-Deskriptoren, >= fd im Einsatz. Da der Prozess das limit der Ressourcen erreicht wurde das Verzeichnis nicht geöffnet werden kann. Wenn das schließen jedes file-Deskriptor von fd durch die Ressourcen einschränken oder sysconf(_SC_OPEN_MAX) ist als fallback verwendet, wird nichts geschlossen werden.
InformationsquelleAutor der Antwort mark4o
12

POSIX Weg ist:
```
int maxfd=sysconf(_SC_OPEN_MAX);
for(int fd=3; fd<maxfd; fd++)
    close(fd);
```
(beachten Sie, dass die Schließung von 3 bis zu behalten, stdin/stdout/stderr öffnen)

close() harmlos gibt EBADF wenn der file-Deskriptor ist nicht geöffnet. Es gibt keine Notwendigkeit, die Abfälle einem anderen system Aufruf überprüfen.

Einige UNIX-Varianten unterstützen eine closefrom(). Dies vermeidet die übermäßige Anzahl der Aufrufe von close() in Abhängigkeit von der maximal möglichen Datei-Deskriptor-Nummer. Während die beste Lösung, die ich bin mir dessen bewusst, es ist völlig nonportable.

InformationsquelleAutor der Antwort chuck

Ich habe code geschrieben, um alle Plattform-spezifischen features. Alle Funktionen sind async-signal-safe. Dachte, die Leute könnten das nützlich finden. Nur getestet auf OS X jetzt, fühlen Sie sich frei, um zu verbessern/beheben.

//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);
    }
}

InformationsquelleAutor der Antwort

Recht, wenn das Programm gestartet ist und noch nicht geöffnet, nichts. E. g. wie der start von main(). Rohr und Gabel ab sofort ein executer-server. Auf diese Weise ist es den Speicher und andere details ist sauber und man kann es eben auch geben, die Dinge zu Gabel & 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);
}

Wenn du möchtest, dass IO auf das ausgeführte Programm der Testamentsvollstrecker server zu tun haben-Buchse leitet, und Sie können die Verwendung von unix-sockets.

InformationsquelleAutor der Antwort over_optimistic

-2

Warum nicht schließen Sie alle Deskriptoren, die von 0 bis, sagen wir, 10000.

Wäre es ziemlich schnell, und das Schlimmste, was passieren würde, ist EBADF.

InformationsquelleAutor der Antwort alamar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.