manpages-de - en to de translation catalogue (91 entries)

note: type: TH
en: 2019-03-06
de: 6. März 2019

note: type: TH
en: Linux Programmer's Manual
de: Linux-Programmierhandbuch

note: type: SH
en: NAME
de: BEZEICHNUNG

note: type: Plain text
en: select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - synchronous I/O multiplexing
de: select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - synchrones E/A-Zeitmultiplexverfahren

note: type: SH
en: SYNOPSIS
de: ÜBERSICHT

note: type: Plain text
en: /* According to POSIX.1-2001, POSIX.1-2008 */
    B<#include E<lt>sys/select.hE<gt>>
de: /* Laut POSIX.1-2001, POSIX.1-2008 */
    B<#include E<lt>sys/select.hE<gt>>

note: type: Plain text
en: /* According to earlier standards */
    B<#include E<lt>sys/time.hE<gt>>
    B<#include E<lt>sys/types.hE<gt>>
    B<#include E<lt>unistd.hE<gt>>
de: /* Laut älterer Standards */
    B<#include E<lt>sys/time.hE<gt>>
    B<#include E<lt>sys/types.hE<gt>>
    B<#include E<lt>unistd.hE<gt>>

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
de: Mit Glibc erforderliche Makros (siehe B<feature_test_macros>(7)):

note: type: SH
en: DESCRIPTION
de: BESCHREIBUNG

note: type: Plain text
en: B<select>()  and B<pselect>()  allow a program to monitor multiple file descriptors, waiting until one or more of the file descriptors become "ready" for some class of I/O operation (e.g., input possible).  A file descriptor is considered ready if it is possible to perform a corresponding I/O operation (e.g., B<read>(2), or a sufficiently small B<write>(2))  without blocking.
de: Mit den Funktionen B<select>() und B<pselect>() kann ein Programm mehrere Dateideskriptoren überwachen und warten, bis ein oder mehrere der Dateideskriptoren »bereit« für eine Klasse von E/A-Aktionen sind (z.\ B. Eingabe möglich). Ein Dateideskriptor gilt als bereit, wenn es möglich ist, eine entsprechende E/A-Aktionen (z.B. B<read> (2) oder ein hinreichend kleines B<write>(2) ohne zu blockieren) durchzuführen.

note: type: Plain text
en: B<select>()  can monitor only file descriptors numbers that are less than B<FD_SETSIZE>; B<poll>(2)  does not have this limitation.  See BUGS.
de: B<select>() kann nur Dateideskriptorennummern überwachen, die kleiner als B<FD_SETSIZE> sind; B<poll>(2) hat diese Einschränkung nicht. Siehe FEHLER.

note: type: Plain text
en: The operation of B<select>()  and B<pselect>()  is identical, other than these three differences:
de: Das Verhalten von B<select>() und B<pselect>() ist bis die folgenden drei Unterschiede identisch:

note: type: Plain text
en: B<select>()  uses a timeout that is a I<struct timeval> (with seconds and microseconds), while B<pselect>()  uses a I<struct timespec> (with seconds and nanoseconds).
de: B<select>() verwendet für Wartezeiten ein I<struct timeval> (mit Sekunden und Mikrosekunden), während B<pselect>() stattdessen ein I<struct timespec> (mit Sekunden und Nanosekunden) verwendet.

note: type: Plain text
en: B<select>()  may update the I<timeout> argument to indicate how much time was left.  B<pselect>()  does not change this argument.
de: Während B<select>() das Argument I<timeout> ändern darf, um die verbleibende Zeit anzugeben, verändert B<pselect>() dieses Argument nicht.

note: type: Plain text
en: B<select>()  has no I<sigmask> argument, and behaves as B<pselect>()  called with NULL I<sigmask>.
de: Die Funktion B<select>() hat keinen Parameter I<sigmask> und verhält sich wie B<pselect>, wenn ihr für I<sigmask> ein NULL-Zeiger übergeben wird.

note: type: Plain text
en: Three independent sets of file descriptors are watched.  The file descriptors listed in I<readfds> will be watched to see if characters become available for reading (more precisely, to see if a read will not block; in particular, a file descriptor is also ready on end-of-file).  The file descriptors in I<writefds> will be watched to see if space is available for write (though a large write may still block).  The file descriptors in I<exceptfds> will be watched for exceptional conditions.  (For examples of some exceptional conditions, see the discussion of B<POLLPRI> in B<poll>(2).)
de: Es werden drei voneinander unabhängige Mengen von Deskriptoren überwacht. Die in I<readfds> aufgeführten Deskriptoren werden daraufhin beobachtet, ob neue Zeichen zum Lesen ankommen (genauer: ob eine Leseaktion nicht blockiert; insbesondere ist ein Dateideskriptor auch am Dateiende (EOF) bereit). Die Datei-Deskriptoren in I<writefds> werden daraufhin beobachtet, ob Platz zum Schreiben verfügbar ist (ein größerer Schreibaufruf kann aber dennoch blockieren) und die Datei-Deskriptoren in I<exceptfds> werden auf außergewöhnliche Bedingungen überwacht. (Lesen Sie die Diskussion von B<POLLPRI> in B<poll>(2) für Beispiele für außergewöhnliche Bedingungen.)

note: type: Plain text
en: On exit, each of the file descriptor sets is modified in place to indicate which file descriptors actually changed status.  (Thus, if using B<select>()  within a loop, the sets must be reinitialized before each call.)
de: Wenn die Funktion beendet wird, wird jede der Datei-Deskriptorenmengen so verändert, dass sie anzeigen, welcher Deskriptor seinen Status geändert hat. (Falls Sie daher B<select>() innerhalb einer Schleife verwenden, müssen die Mengen vor jedem Aufruf neu initialisiert werden.)

note: type: Plain text
en: Each of the three file descriptor sets may be specified as NULL if no file descriptors are to be watched for the corresponding class of events.
de: Jeder der drei Mengen von Deskriptoren kann als NULL angegeben werden, falls für die entsprechenden Dateideskriptoren keine Klassen oder Ereignisse überwacht werden müssen.

note: type: Plain text
en: Four macros are provided to manipulate the sets.  B<FD_ZERO>()  clears a set.  B<FD_SET>()  and B<FD_CLR>()  add and remove a given file descriptor from a set.  B<FD_ISSET>()  tests to see if a file descriptor is part of the set; this is useful after B<select>()  returns.
de: Es werden vier Makros bereitgestellt, um mit diesen Mengen zu arbeiten. B<FD_ZERO>() löscht eine Menge, B<FD_SET>() fügt einen Deskriptor zu einer Menge hinzu und B<FD_CLR>() löscht diesen. B<FD_ISSET>() prüft, ob der Deskriptor in der Menge enthalten ist. Das ist insbesondere nach einem Aufruf von B<select>() nützlich.

note: type: Plain text
en: I<nfds> should be set to the highest-numbered file descriptor in any of the three sets, plus 1.  The indicated file descriptors in each set are checked, up to this limit (but see BUGS).
de: I<nfds> sollte auf die Nummer des am höchsten nummerierten Dateideskriptors in allen drei Mengen plus 1 gesetzt werden. Der gekennzeichnete Dateideskriptor in jeder der drei Mengen wird bis zu dieser Begrenzung geprüft (siehe aber FEHLER).

note: type: Plain text
en: The I<timeout> argument specifies the interval that B<select>()  should block waiting for a file descriptor to become ready.  The call will block until either:
de: Das Argument I<timeout> legt das Intervall fest, das B<select>() warten sollte, bis ein Dateideskriptor bereit wird. Der Aufruf wird blockieren, bis entweder:

note: type: Plain text
en: a file descriptor becomes ready;
de: ein Dateideskriptor bereit wird,

note: type: Plain text
en: the call is interrupted by a signal handler; or
de: der Aufruf durch einen Signal-Handler unterbrochen wird, oder

note: type: Plain text
en: the timeout expires.
de: die Wartezeit abläuft.

note: type: Plain text
en: Note that the I<timeout> interval will be rounded up to the system clock granularity, and kernel scheduling delays mean that the blocking interval may overrun by a small amount.  If both fields of the I<timeval> structure are zero, then B<select>()  returns immediately.  (This is useful for polling.)  If I<timeout> is NULL (no timeout), B<select>()  can block indefinitely.
de: Beachten Sie, das das Intervall I<timeout> auf die Auflösung der Systemuhr aufgerundet wird. Durch Verzögerungen beim Kernel-Scheduling kann dieser Wert nochmals etwas größer werden. Falls beide Felder der Struktur I<timeval> gleich null sind, kehrt B<select>() sofort zurück. (Das ist praktisch für Polling). Falls I<timeout> gleich NULL ist (keine Wartezeit), kann B<select>() auf unbestimmte Zeit blockieren.

note: type: Plain text
en: I<sigmask> is a pointer to a signal mask (see B<sigprocmask>(2)); if it is not NULL, then B<pselect>()  first replaces the current signal mask by the one pointed to by I<sigmask>, then does the "select" function, and then restores the original signal mask.
de: I<sigmask> ist ein Zeiger auf eine Signalmaske (siehe B<sigprocmask>(2)); falls er ungleich NULL ist, ersetzt B<pselect>() zuerst die aktuelle Signalmaske mit derjenigen, auf die I<sigmask> weist, erledigt danach die »select«-Funktion und stellt als Letztes die ursprüngliche Signalmaske wieder her.

note: type: Plain text
en: Other than the difference in the precision of the I<timeout> argument, the following B<pselect>()  call:
de: Abgesehen von der unterschiedlichen Genauigkeit des I<timeout>-Arguments ist der B<pselect>()-Aufruf

note: type: Plain text
en: is equivalent to I<atomically> executing the following calls:
de: ist äquivalent zur I<atomaren> Ausführung der folgenden Aufrufe:

note: type: Plain text
en: The reason that B<pselect>()  is needed is that if one wants to wait for either a signal or for a file descriptor to become ready, then an atomic test is needed to prevent race conditions.  (Suppose the signal handler sets a global flag and returns.  Then a test of this global flag followed by a call of B<select>()  could hang indefinitely if the signal arrived just after the test but just before the call.  By contrast, B<pselect>()  allows one to first block signals, handle the signals that have come in, then call B<pselect>()  with the desired I<sigmask>, avoiding the race.)
de: Falls man auf die Verfügbarkeit eines Signals oder eines Dateideskriptors warten möchte, ist zur Vermeidung von Wettlaufsituationen (race conditions) eine atomare Prüfung erforderlich, die von B<pselect>() erledigt wird. (Angenommen, der Signal Handler setzt einen globalen Schalter und kehrt zurück. Dann könnte eine Prüfung dieses globalen Schalters gefolgt von einem Aufruf von B<select>() auf unbestimmte Zeit hängen, wenn das Signal zwischen der Prüfung und vor dem Aufruf von B<select>() eintrifft. Im Gegensatz dazu ermöglicht es B<pselect>() zuerst Signale zu blockieren, die eingetroffenen Signale abzuarbeiten und anschließend B<pselect>() mit der gewünschten I<sigmask> aufzurufen, um Race Conditions zu vermeiden.)

note: type: SS
en: The timeout
de: Die Wartezeit (timeout)

note: type: Plain text
en: The time structures involved are defined in I<E<lt>sys/time.hE<gt>> and look like
de: Die Zeitstrukturen sind in I<E<lt>sys/time.hE<gt>> als

note: type: Plain text
en: struct timeval {
        long    tv_sec;         /* seconds */
        long    tv_usec;        /* microseconds */
    };
de: struct timeval {
        long    tv_sec;         /* Sekunden */
        long    tv_usec;        /* Mikrosekunden */
    };

note: type: Plain text
en: and
de: und

note: type: Plain text
en: struct timespec {
        long    tv_sec;         /* seconds */
        long    tv_nsec;        /* nanoseconds */
    };
de: struct timespec {
        long    tv_sec;         /* Sekunden */
        long    tv_nsec;        /* Nanosekunden */
    };

note: type: Plain text
en: (However, see below on the POSIX.1 versions.)
de: definiert. (Sehen Sie sich aber weiter unten die Besonderheiten der POSIX.1-Versionen an.)

note: type: Plain text
en: Some code calls B<select>()  with all three sets empty, I<nfds> zero, and a non-NULL I<timeout> as a fairly portable way to sleep with subsecond precision.
de: Es gibt Code, der B<select> wie folgt aufruft: alle drei Deskriptor-Mengen leer, I<nfds> gleich null und ein von NULL verschiedenes I<timeout> als recht portabler Weg, um mit Auflösungen unterhalb einer Sekunde zu schlafen.

note: .PP - it is rumored that: On BSD, when a timeout occurs, the file descriptor bits are not changed. - it is certainly true that: Linux follows SUSv2 and sets the bit masks to zero upon a timeout. type: Plain text
en: On Linux, B<select>()  modifies I<timeout> to reflect the amount of time not slept; most other implementations do not do this.  (POSIX.1 permits either behavior.)  This causes problems both when Linux code which reads I<timeout> is ported to other operating systems, and when code is ported to Linux that reuses a I<struct timeval> for multiple B<select>()s in a loop without reinitializing it.  Consider I<timeout> to be undefined after B<select>()  returns.
de: Unter Linux modifiziert B<select>() I<timeout>, um die nicht schlafend verbrachte Zeit anzuzeigen; die meisten anderen Implementierungen tun das nicht. (POSIX.1 lässt beiderlei Verhalten zu.) Dies führt zu Problemen sowohl bei der Portierung von Linux-Code, der I<timeout> liest, auf andere Betriebssysteme als auch bei der Portierung von Code nach Linux, der eine I<struct timeval> in einer Schleife für mehrfache Aufrufe von B<select>() nutzt, ohne sie erneut zu initialisieren. Gehen Sie davon aus, dass I<timeout> nach der Rückkehr aus B<select>() nicht definiert ist.

note: type: SH
en: RETURN VALUE
de: RÜCKGABEWERT

note: type: Plain text
en: On success, B<select>()  and B<pselect>()  return the number of file descriptors contained in the three returned descriptor sets (that is, the total number of bits that are set in I<readfds>, I<writefds>, I<exceptfds>)  which may be zero if the timeout expires before anything interesting happens.  On error, -1 is returned, and I<errno> is set to indicate the error; the file descriptor sets are unmodified, and I<timeout> becomes undefined.
de: Bei Erfolg geben B<select>() und B<pselect>() die Anzahl der Datei-Deskriptoren in den drei zurückgegebenen Deskriptor-Mengen zurück. (Das entspricht der Gesamtzahl von Bits, die in I<readfds>, I<writefds> und I<exceptfds> gesetzt sind.) Der Wert kann null sein, falls die Wartezeit abläuft, ohne das irgendetwas von Bedeutung geschieht. Wenn ein Fehler auftritt, wird -1 zurückgegeben und I<errno> gesetzt, um den Fehler anzugeben. Die Datei-Deskriptor-Mengen bleiben unverändert und I<timeout> wird undefiniert.

note: type: SH
en: ERRORS
de: FEHLER

note: type: Plain text
en: An invalid file descriptor was given in one of the sets.  (Perhaps a file descriptor that was already closed, or one on which an error has occurred.)  However, see BUGS.
de: In einem der Mengen wurde ein ungültiger Dateideskriptor angegeben. (Vielleicht war es ein schon geschlossener Dateideskriptor oder einer, bei dem ein Fehler aufgetreten ist.) Lesen Sie aber auch FEHLER.

note: type: Plain text
en: A signal was caught; see B<signal>(7).
de: Ein Signal wurde abgefangen; siehe B<signal>(7).

note: type: Plain text
en: I<nfds> is negative or exceeds the B<RLIMIT_NOFILE> resource limit (see B<getrlimit>(2)).
de: I<nfds> ist negativ oder übersteigt die Ressourcenbegrenzung B<RLIMIT_NOFILE> (siehe B<getrlimit>(2)).

note: type: Plain text
en: The value contained within I<timeout> is invalid.
de: Der Wert von I<timeout> ist ungültig.

note: type: Plain text
en: Unable to allocate memory for internal tables.
de: Speicher für interne Tabellen konnte nicht bereitgestellt werden.

note: type: SH
en: VERSIONS
de: VERSIONEN

note: type: Plain text
en: B<pselect>()  was added to Linux in kernel 2.6.16.  Prior to this, B<pselect>()  was emulated in glibc (but see BUGS).
de: B<pselect>() wurde im Linux-Kernel 2.6.16 hinzugefügt. Vorher wurde B<pselect>() in der Glibc emuliert (siehe aber FEHLER).

note: type: SH
en: CONFORMING TO
de: KONFORM ZU

note: type: Plain text
en: B<select>()  conforms to POSIX.1-2001, POSIX.1-2008, and 4.4BSD (B<select>()  first appeared in 4.2BSD).  Generally portable to/from non-BSD systems supporting clones of the BSD socket layer (including System\ V variants).  However, note that the System\ V variant typically sets the timeout variable before exit, but the BSD variant does not.
de: B<select>() erfüllt POSIX.1-2001, POSIX.1-2008 und 4.4BSD (B<select>() erschien erstmalig in 4.2BSD). Im Allgemeinen von/nach nicht BSD-Systeme portabel, unterstützt Klone der BSD-Socket-Schicht (einschließlich System-V-Varianten). Beachten Sie allerdings, dass System-V-Varianten typischerweise die Variable »timeout« vor dem Beenden setzen, die BSD-Variante aber nicht.

note: type: Plain text
en: B<pselect>()  is defined in POSIX.1g, and in POSIX.1-2001 and POSIX.1-2008.
de: B<pselect>() ist in POSIX.1g und in POSIX.1-2001 und in POSIX.1-2008 definiert.

note: type: SH
en: NOTES
de: ANMERKUNGEN

note: type: Plain text
en: An I<fd_set> is a fixed size buffer.  Executing B<FD_CLR>()  or B<FD_SET>()  with a value of I<fd> that is negative or is equal to or larger than B<FD_SETSIZE> will result in undefined behavior.  Moreover, POSIX requires I<fd> to be a valid file descriptor.
de: Ein I<fd_set> ist ein Puffer fester Größe. Wird B<FD_CLR>() oder B<FD_SET>() mit einem Wert für I<fd>, der negativ, gleich groß oder größer als B<FD_SETSIZE> ist, ausgeführt, führt dies zu nicht definiertem Verhalten. Desweiteren verlangt POSIX, dass I<fd> ein gültiger Dateideskriptor ist.

note: type: Plain text
en: The operation of B<select>()  and B<pselect>()  is not affected by the B<O_NONBLOCK> flag.
de: Das Verhalten von B<select>() und B<pselect>() ist von dem Schalter B<O_NONBLOCK> nicht betroffen.

note: Darwin, according to a report by Jeremy Sequoia, relayed by Josh Triplett type: Plain text
en: On some other UNIX systems, B<select>()  can fail with the error B<EAGAIN> if the system fails to allocate kernel-internal resources, rather than B<ENOMEM> as Linux does.  POSIX specifies this error for B<poll>(2), but not for B<select>().  Portable programs may wish to check for B<EAGAIN> and loop, just as with B<EINTR>.
de: Unter einigen UNIX-Systemen kann B<select>() mit dem Fehler B<EAGAIN> fehlschlagen, falls es dem System nicht gelingt, Kernel-interne Ressourcen zuzuweisen. Linux verwendet hierbei B<ENOMEM>. POSIX legt diesen Fehler für B<poll>(2) aber nicht für B<select>() fest. Portable Anwendungen könnten in einer Schleife auf B<EAGAIN> (wie auch auf B<EINTR>) prüfen.

note: type: Plain text
en: On systems that lack B<pselect>(), reliable (and more portable) signal trapping can be achieved using the self-pipe trick.  In this technique, a signal handler writes a byte to a pipe whose other end is monitored by B<select>()  in the main program.  (To avoid possibly blocking when writing to a pipe that may be full or reading from a pipe that may be empty, nonblocking I/O is used when reading from and writing to the pipe.)
de: Auf Systemen, auf denen B<pselect>() fehlt, kann ein zuverlässiges (und portableres) Abfangen von Signalen mit dem Selbst-Pipe-Trick erreicht werden. Bei dieser Technik schreibt ein Signal-Handler ein Byte in eine Pipe, dessen anderes Ende von B<select>() im Hauptprogramm überwacht wird. (Um mögliches Blockieren beim Schreiben in eine Pipe, die voll sein könnte, oder Lesen aus einer Pipe, die leer sein könnte, zu vermeiden, wird nicht blockierende E/A beim Auslesen und Schreiben in die Pipe verwandt.)

note: type: Plain text
en: Concerning the types involved, the classical situation is that the two fields of a I<timeval> structure are typed as I<long> (as shown above), and the structure is defined in I<E<lt>sys/time.hE<gt>>.  The POSIX.1 situation is
de: Im Hinblick auf die beteiligten Typen ist die klassische Situation, dass zwei Felder einer Struktur I<timeval> vom Typ I<long> (wie gezeigt) sind und die Struktur in I<E<lt>sys/time.hE<gt>> definiert ist. Die POSIX.1-Situation ist

note: type: Plain text
en: struct timeval {
        time_t         tv_sec;     /* seconds */
        suseconds_t    tv_usec;    /* microseconds */
    };
de: struct timeval {
        time_t         tv_sec;     /* Sekunden */
        suseconds_t    tv_usec;    /* Mikrosekunden */
    };

note: type: Plain text
en: where the structure is defined in I<E<lt>sys/select.hE<gt>> and the data types I<time_t> and I<suseconds_t> are defined in I<E<lt>sys/types.hE<gt>>.
de: wobei die Struktur in I<E<lt>sys/select.hE<gt>> definiert und die Datentypen I<time_t> und I<suseconds_t> in I<E<lt>sys/types.hE<gt>> definiert sind.

note: type: Plain text
en: Concerning prototypes, the classical situation is that one should include I<E<lt>time.hE<gt>> for B<select>().  The POSIX.1 situation is that one should include I<E<lt>sys/select.hE<gt>> for B<select>()  and B<pselect>().
de: Im Hinblick auf Prototypen ist die klassische Situation, dass I<E<lt>time.hE<gt>> für B<select>() eingebunden werden sollte. Die Situation unter POSIX.1 ist, dass I<E<lt>sys/select.hE<gt>> für B<select>() und B<pselect>() eingebunden werden sollte.

note: type: Plain text
en: Under glibc 2.0, I<E<lt>sys/select.hE<gt>> gives the wrong prototype for B<pselect>().  Under glibc 2.1 to 2.2.1, it gives B<pselect>()  when B<_GNU_SOURCE> is defined.  Since glibc 2.2.2, the requirements are as shown in the SYNOPSIS.
de: Unter Glibc 2.0 gibt I<E<lt>sys/select.hE<gt>> den falschen Prototyp für B<pselect>(). Unter Glibc 2.1 bis 2.2.1 gibt er B<pselect>(), wenn B<_GNU_SOURCE> definiert ist. Seit Glibc 2.2.2 gelten die in ÜBERSICHT gezeigten Anforderungen.

note: type: SS
en: Correspondence between select() and poll() notifications
de: Korrespondenz zwischen den Benachrichtigungen select() und poll()

note: fs/select.c type: Plain text
en: Within the Linux kernel source, we find the following definitions which show the correspondence between the readable, writable, and exceptional condition notifications of B<select>()  and the event notifications provided by B<poll>(2)  (and B<epoll>(7)):
de: Innerhalb der Linux-Kernelquellen finden wir die folgende Definition, die die Korrespondenz zwischen den lesbaren, schreibbaren und außerordentlichen Zustandsbenachrichtigungen von B<select>() und den durch B<poll>(2) (und B<epoll>(7)) bereitgestellten Ereignisbenachrichtigungen zeigt:

note: type: Plain text
en: #define POLLIN_SET (POLLRDNORM | POLLRDBAND | POLLIN | POLLHUP |
                        POLLERR)
                       /* Ready for reading */
    #define POLLOUT_SET (POLLWRBAND | POLLWRNORM | POLLOUT | POLLERR)
                       /* Ready for writing */
    #define POLLEX_SET (POLLPRI)
                       /* Exceptional condition */
de: #define POLLIN_SET (POLLRDNORM | POLLRDBAND | POLLIN | POLLHUP |
                        POLLERR)
                       /* Bereit zum Lesen */
    #define POLLOUT_SET (POLLWRBAND | POLLWRNORM | POLLOUT | POLLERR)
                       /* Bereit zum Schreiben */
    #define POLLEX_SET (POLLPRI)
                       /* Außergewöhnliche Bedingung */

note: type: SS
en: Multithreaded applications
de: Multithreaded Anwendungen

note: type: Plain text
en: If a file descriptor being monitored by B<select>()  is closed in another thread, the result is unspecified.  On some UNIX systems, B<select>()  unblocks and returns, with an indication that the file descriptor is ready (a subsequent I/O operation will likely fail with an error, unless another process reopens file descriptor between the time B<select>()  returned and the I/O operation is performed).  On Linux (and some other systems), closing the file descriptor in another thread has no effect on B<select>().  In summary, any application that relies on a particular behavior in this scenario must be considered buggy.
de: Falls ein Dateideskriptor, der durch B<select>() überwacht wird, in einem anderen Thread geschlossen wird, ist das Ergebnis nicht spezifiziert. Auf einigen UNIX-Systemen entblockt B<select>() und kehrt mit einer Information zurück, dass der Dateideskriptor bereit ist (eine nachfolgende E/A-Aktion wird wahrscheinlich mit einem Fehler fehlschlagen, außer ein anderer Prozess hat den Dateideskriptor zwischen dem Zeitpunkt, zu dem B<select>() zurückkehrte, und dem Zeitpunkt, zu der die E/A-Aktion stattfindet, wieder geöffnet). Unter Linux (und einigen anderen Systemen) hat das Schließen des Dateideskriptors in einem anderen Thread keinen Effekt auf B<select>(). Zusammenfassend sollte jede Anwendung, die sich auf ein bestimmtes Verhalten in diesem Szenario abstützt, als fehlerhaft betrachtet werden.

note: type: SS
en: C library/kernel differences
de: Unterschiede C-Bibliothek/Kernel

note: type: Plain text
en: The Linux kernel allows file descriptor sets of arbitrary size, determining the length of the sets to be checked from the value of I<nfds>.  However, in the glibc implementation, the I<fd_set> type is fixed in size.  See also BUGS.
de: Der Linux-Kernel erlaubt Dateideskriptormengen beliebiger Größe und bestimmt die Größe der zu prüfenden Mengen durch den Wert von I<nfds>. In der Glibc-Implementierung ist der Typ I<fd_set> allerdings von fester Größe. Siehe auch FEHLER.

note: type: Plain text
en: The B<pselect>()  interface described in this page is implemented by glibc.  The underlying Linux system call is named B<pselect6>().  This system call has somewhat different behavior from the glibc wrapper function.
de: Die in dieser Seite beschriebene Schnittstelle von B<pselect>() wird durch Glibc implementiert. Der darunterliegende Systemaufruf heißt B<pselect6>(). Dieser Systemaufruf hat ein etwas anderes Verhalten als die Glibc-Wrapper-Funktion.

note: type: Plain text
en: The Linux B<pselect6>()  system call modifies its I<timeout> argument.  However, the glibc wrapper function hides this behavior by using a local variable for the timeout argument that is passed to the system call.  Thus, the glibc B<pselect>()  function does not modify its I<timeout> argument; this is the behavior required by POSIX.1-2001.
de: Der Systemaufruf B<pselect6>() von Linux verändert das Argument I<timeout>. Die Glibc-Wrapper-Funktion versteckt dieses Verhalten durch Verwendung einer lokalen Variablen für das Argument »timeout«, die an den Systemaufruf übergeben wird. Daher verändert die Glibc-Funktion B<pselect>() nicht ihr Argument I<timeout>; dies ist das von POSIX.1-2001 verlangte Verhalten.

note: type: Plain text
en: The final argument of the B<pselect6>()  system call is not a I<sigset_t\ *> pointer, but is instead a structure of the form:
de: Das finale Argument des Systemaufrufs B<pselect6>() ist kein I<sigset_t\ *>-Zeiger, sondern eine Struktur der folgenden Form:

note: type: Plain text
en: struct {
        const kernel_sigset_t *ss;   /* Pointer to signal set */
        size_t ss_len;               /* Size (in bytes) of object
                                        pointed to by 'ss' */
    };
de: struct {
        const kernel_sigset_t *ss;  /* Zeiger auf Signalgruppe */
        size_t ss_len;              /* Größe (in Bytes) des Objekts,
                                       auf das durch »ss« gezeigt wird */
    };

note: type: Plain text
en: This allows the system call to obtain both a pointer to the signal set and its size, while allowing for the fact that most architectures support a maximum of 6 arguments to a system call.  See B<sigprocmask>(2)  for a discussion of the difference between the kernel and libc notion of the signal set.
de: Dies erlaubt es dem Systemaufruf, sowohl einen Zeiger auf die Signalgruppe als auch seine Größe zu ermitteln und dabei zu berücksichtigen, dass die meisten Architekturen eine maximale Anzahl von 6 Argumenten für einen Systemaufruf erlauben. Siehe B<sigprocmask>(2) für eine Diskussion der Unterschiede zwischen der Ansicht des Kernels und der Ansicht der Libc bezüglich der Singalmenge.

note: type: SH
en: BUGS
de: FEHLER

note: type: Plain text
en: POSIX allows an implementation to define an upper limit, advertised via the constant B<FD_SETSIZE>, on the range of file descriptors that can be specified in a file descriptor set.  The Linux kernel imposes no fixed limit, but the glibc implementation makes I<fd_set> a fixed-size type, with B<FD_SETSIZE> defined as 1024, and the B<FD_*>()  macros operating according to that limit.  To monitor file descriptors greater than 1023, use B<poll>(2)  instead.
de: POSIX erlaubt einer Implementierung, eine oberer Begrenzung für den Bereich von Dateideskriptoren, die in einer Dateideskriptorenmenge festgelegt werden können, zu definieren. Diese Begrenzung soll mittels der Konstanten B<FD_SETSIZE> bekannt gemacht werden. Der Linux-Kernel erzwingt keine feste Begrenzung, aber die Glibc-Implementierung macht I<fd_set> zu einem Typ fester Größe, wobei B<FD_SETSIZE> als 1024 definiert ist und die Makros B<FD_*>() arbeiten entsprechend dieser Begrenzung. Um Dateideskriptoren größer als 1024 zu überwachen verwenden Sie stattdessen B<poll>(2).

note: type: Plain text
en: The implementation of the I<fd_set> arguments as value-result arguments means that they must be reinitialized on each call to B<select>().  This design error is avoided by B<poll>(2), which uses separate structure fields for the input and output of the call.
de: Die Implementierung der Argumente I<fd_set> als Wert-Ergebnis-Argumente bedeutet, dass sie bei jedem Aufruf von B<select>() neu initialisiert werden müssen. Dieser Design-Fehler wird von B<poll>(2) vermieden, der getrennte Strukturfelder für die Ein- und Ausgabe des Aufrufs verwendet.

note: type: Plain text
en: According to POSIX, B<select>()  should check all specified file descriptors in the three file descriptor sets, up to the limit I<nfds-1>.  However, the current implementation ignores any file descriptor in these sets that is greater than the maximum file descriptor number that the process currently has open.  According to POSIX, any such file descriptor that is specified in one of the sets should result in the error B<EBADF>.
de: Laut POSIX sollte B<select>() alle festgelegten Dateideskriptoren in den drei Dateideskriptorenmengen bis zur Grenze I<nfds-1> prüfen. Allerdings ignoriert die aktuelle Implementierung jeden Dateideskriptor in diesen Mengen, der größer als die maximale Dateideskriptorennummer ist, die der Prozess derzeit offen hat. Laut POSIX sollte jeder solcher Dateideskriptoren, der in einem der drei Mengen festgelegt ist, zu einem Fehler B<EBADF> führen.

note: type: Plain text
en: Glibc 2.0 provided a version of B<pselect>()  that did not take a I<sigmask> argument.
de: Glibc 2.0 stellte eine Version von B<pselect>() bereit, die das Argument I<sigmask> nicht akzeptierte.

note: type: Plain text
en: Starting with version 2.1, glibc provided an emulation of B<pselect>()  that was implemented using B<sigprocmask>(2)  and B<select>().  This implementation remained vulnerable to the very race condition that B<pselect>()  was designed to prevent.  Modern versions of glibc use the (race-free)  B<pselect>()  system call on kernels where it is provided.
de: Beginnend mit Version 2.1 stellt Glibc eine Emulation von B<pselect>() bereit, die mittels B<sigprocmask>(2) und B<select>() implementiert wurde. Diese Implementierung blieb für den starken Ressourcenwettlauf verwundbar, der durch das Design von B<pselect>() vermieden werden sollte. Moderne Versionen der Glibc verwenden den (ressourcenwettlauffreien) B<pselect>()-Systemaufruf auf Kerneln, die ihn bereitstellen.

note: Stevens discusses a case where accept can block after select returns successfully because of an intervening RST from the client. Maybe the kernel should have returned EIO in such a situation? type: Plain text
en: Under Linux, B<select>()  may report a socket file descriptor as "ready for reading", while nevertheless a subsequent read blocks.  This could for example happen when data has arrived but upon examination has wrong checksum and is discarded.  There may be other circumstances in which a file descriptor is spuriously reported as ready.  Thus it may be safer to use B<O_NONBLOCK> on sockets that should not block.
de: Unter Linux könnte B<select>() einen Socket-Dateideskriptor als »bereit zum Lesen« melden, obwohl trotzdem ein folgendes Lesen blockiert. Dies könnte beispielsweise passieren, wenn Daten angekommen sind, aber bei genauerer Prüfung die falsche Prüfsumme haben und daher verworfen werden. Es mag andere Umstände geben, in denen ein Dateideskriptor fälschlicherweise als bereit berichtet werden könnte. Daher mag es sicherer sein, B<O_NONBLOCK> bei Sockets zu benutzen, die nicht blockieren sollen.

note: type: Plain text
en: On Linux, B<select>()  also modifies I<timeout> if the call is interrupted by a signal handler (i.e., the B<EINTR> error return).  This is not permitted by POSIX.1.  The Linux B<pselect>()  system call has the same behavior, but the glibc wrapper hides this behavior by internally copying the I<timeout> to a local variable and passing that variable to the system call.
de: Unter Linux verändert B<select>() auch I<timeout> falls der Aufruf durch ein Signal-Handler unterbrochen wird (d.h. den Fehler B<EINTR> zurückliefert). Dies wird von POSIX.1 nicht erlaubt. Der Linux-Systemaufruf B<pselect>() zeigt das gleiche Verhalten, aber der Glibc-Wrapper versteckt das Verhalten, indem er intern I<timeout> in eine lokale Variable kopiert und diese Variable an den Systemaufruf übergibt.

note: type: SH
en: EXAMPLE
de: BEISPIEL

note: type: Plain text
en:     /* Watch stdin (fd 0) to see when it has input. */
de:     /* Beobachte stdin (fd 0), um zu sehen, wenn es Eingaben gibt. */

note: type: Plain text
en:     /* Wait up to five seconds. */
de:     /* Warte bis zu fünf Sekunden. */

note: type: Plain text
en:     retval = select(1, &rfds, NULL, NULL, &tv);
        /* Don't rely on the value of tv now! */
de:     retval = select(1, &rfds, NULL, NULL, &tv);
        /* Verlassen Sie sich jetzt nicht auf den Wert von tv! */

note: type: Plain text
en:     if (retval == -1)
            perror("select()");
        else if (retval)
            printf("Data is available now.\en");
            /* FD_ISSET(0, &rfds) will be true. */
        else
            printf("No data within five seconds.\en");
de:     if (retval == -1)
            perror("select()");
        else if (retval)
            printf("Daten sind jetzt verfügbar.\en");
            /* FD_ISSET(0, &rfds) werden wahr sein. */
        else
            printf("Innerhalb von fünf Sekunden keine Daten.\en");

note: type: SH
en: SEE ALSO
de: SIEHE AUCH

note: type: Plain text
en: For a tutorial with discussion and examples, see B<select_tut>(2).
de: Für eine Anleitung mit Diskussionen und Beispielen lesen Sie B<select_tut>(2).

note: type: SH
en: COLOPHON
de: KOLOPHON

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.03 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.02 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.01 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.
