.\" This manpage is copyright (C) 2001 Paul Sheer.
.\"
.\" Permission is granted to make and distribute verbatim copies of this
.\" manual provided the copyright notice and this permission notice are
.\" preserved on all copies.
.\"
.\" Permission is granted to copy and distribute modified versions of this
.\" manual under the conditions for verbatim copying, provided that the
.\" entire resulting derived work is distributed under the terms of a
.\" permission notice identical to this one.
.\" 
.\" Since the Linux kernel and libraries are constantly changing, this
.\" manual page may be incorrect or out-of-date.  The author(s) assume no
.\" responsibility for errors or omissions, or for damages resulting from
.\" the use of the information contained herein.  The author(s) may not
.\" have taken the same level of care in the production of this manual,
.\" which is licensed free of charge, as they might when working
.\" professionally.
.\" 
.\" Formatted or processed versions of this manual, if unaccompanied by
.\" the source, must acknowledge the copyright and authors of this work.
.\"
.\" very minor changes, aeb
.\"
.\" Modified 5 June 2002, Michael Kerrisk <mtk-manpages@gmx.net>
.\"
.\" Translated Thu 21 Feb 2002 by NAKANO Takeo <nakano@apm.seikei.ac.jp>
.\" Updated Mon 23 Sep 2002 by Akihiro MOTOKI <amotoki@dd.iij4u.or.jp>
.\"
.\"WORD: file descriptor	ե롦ǥץ
.\"
.TH SELECT_TUT 2 "October 21, 2001" "Linux 2.4" "Linux Programmer's Manual"
.SH ̾
select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO \- Ʊ I/O ¿Ų (multiplexing)
.SH 
.B #include <sys/time.h>
.br
.B #include <sys/types.h>
.br
.B #include <unistd.h>
.sp
.BI "int select(int " nfds ", fd_set *" readfds ,
.BI "fd_set *" writefds ", fd_set *" exceptfds ,
.BI "struct timeval *" utimeout );
.sp
.BI "int pselect(int " nfds ", fd_set *" readfds ,
.BI "fd_set *" writefds ", fd_set *" exceptfds ,
.BI "const struct timespec *" ntimeout ", sigset_t *" sigmask );
.sp
.BI "FD_CLR(int " fd ", fd_set *" set );
.br
.BI "FD_ISSET(int " fd ", fd_set *" set );
.br
.BI "FD_SET(int " fd ", fd_set *" set );
.br
.BI "FD_ZERO(fd_set *" set );
.fi
.SH 
.B select
(ޤ
.BR pselect )
ϡƱʣΥե롦ǥץ (ޤϥåȥϥɥ)
ΨŪ˰Ȥ C ץǡפȤʤؿǤ롣
δؿμפʰϡ3Υե롦ǥץ
\fIreadfds\fP, \fIwritefds\fP, \fIexceptfds\fP Ǥ롣
\fBselect\fP ̾λȤϡҤȤĤޤʣΥե롦ǥץ
־֤ѲפԤäƤ֤ (block) 뤳ȤǤ롣
־֤ѲפȤϡʲΤ줫ξǤ:
(1) ե롦ǥץǤʸ硢
(2) ե롦ǥץ˽񤭹ि
ͥХåեǶ֤ѤǤ褦ˤʤä硢
(3) ե롦ǥץ顼ˤʤä
(åȤѥפξϡ³¾ü줿)

󤹤ȡ\fBselect\fP
ñʣΥե롦ǥץƻ뤹Τǡ
ޤԤɸŪ Unix ʤΤǤ롣

ե롦ǥץ
.I ե롦ǥץ (file descriptor set)
ȸƤФ롣ơν
.B fd_set
Ȥ졢Ƥ
\fBFD_CLR\fP, \fBFD_ISSET\fP, \fBFD_SET\fP, \fBFD_ZERO\fP
ȤäޥˤäѹǤ롣
\fBFD_ZERO\fP ̾￷ǥץФ
ǽѤؿǤ롣
θ塢ƻоݤȤ줾Υե롦ǥץ
\fBFD_SET\fP ˤäưİɲäǤ롣
.B select
ϤνƤ򡢰ʹߤ˽Ҥ٤뵬§˽äƽ롣
.B select
Ƥ塢ե롦ǥץޤ¸ߤƤ뤫ɤϡ
\fBFD_ISSET\fP ޥˤäĴ٤뤳ȤǤ롣
\fBFD_ISSET\fP ϤΥǥץ¸ߤƤ 0 ʳ֤ͤ
¸ߤƤʤ 0 ֤
\fBFD_CLR\fP ϥե롦ǥץ򽸹礫
꡼ʥץǤϤȤɬϤʤɮԤϹͤ롣
.SH 
.TP
\fIreadfds\fP
νϡ˴ޤޤ뤤줫Υե롦ǥץ
ǡɤ߹ߤǽˤʤäɤΤ뤿˴ƻ뤵롣
\fBselect\fP ˡ\fIreadfds\fP Τ
\fBrecv()\fP(åȤξ) 
\fBread()\fP(ѥסե롢åȤξ)
ˤäľɤ߹߲ǽʥե롦ǥץʳ
礫롣
.TP
\fIwritefds\fP
νϡ˴ޤޤ뤤줫Υե롦ǥץ
ǡ񤭹ॹڡ뤫ɤΤ뤿˴ƻ뤵롣
\fBselect\fP ˡ\fIwritefds\fP Τ
\fBsend()\fP(åȤξ) 
\fBwrite()\fP(ѥסե롢åȤξ)
ˤäľ˽񤭹߲ǽʥե롦ǥץʳ
礫롣
.TP
\fIexceptfds\fP
νϡ˴ޤޤ뤤줫Υե롦ǥץ
㳰䥨顼ƤʤΤ뤿˴ƻ뤵롣
Ϥα˲᤮
ºݤ \fIexceptfds\fP Ǵƻ뤷ƤΤ
\fIӰ賰 (out-of-band: OOB)\fP ǡʤΤ
OOB ǡϥåȤ \fBMSG_OOB\fP ե饰Ѥ롣
äơºݤˤ \fIexceptfds\fP ϥåȤˤŬѤǤʤ
ξܺ٤ˤĤƤ
.BR recv (2)

.BR send (2)
򸫤衣\fBselect\fP äΤ\fIexceptfds\fP ϥꥢ롣
 OOB ǡɤ߹ߤǽˤʤäƤǥץϥꥢʤ
OOB ǡɤ߹ (\fBrecv()\fP Ȥ)  1 ХȤΤߤǤʤ
OOB ǡν񤭹 (\fBsend()\fP Ȥ) ϤĤǤǤ
 (block) 뤳Ȥʤ
äơåȤ OOB ǡν񤭹ߤǽǤ뤫ɤå
4 ܤνɬפʤΤǤ롣
.TP
\fInfds\fP
Ƥν˴ޤޤե롦ǥץΤ
ͤΤΤ 1 ­Ǥ롣
ʤե롦ǥץ򽸹˲äȤǡ
ƤΥե롦ǥץ򸫤ƺͤᡢ
 1 ä \fInfds\fP Ȥ
\fBselect\fP ϤʤȤʤȤȤ
.TP
\fIutimeout\fP
.RS
 \fBselect\fP  (ⵯʤäȤƤ)
Ԥĺ֤Ǥ롣ͤ \fBNULL\fP Ϥȡ
\fBselect\fP ϲ餫Υ٥ȤԤĤŤƤäȥ֥å롣
\fIutimeout\fP  0 äˤ뤳ȤǤ
ξ \fBselect\fP ľ롣
¤ \fBstruct timeval\fP ϼΤ褦Ƥ:
.PP
.nf
struct timeval {
    time_t tv_sec;    /* seconds */
    long tv_usec;     /* microseconds */
};
.fi
.RE
.TP
\fIntimeout\fP
.RS
ΰ \fIutimeout\fP Ʊ̣Ĥ
\fBstruct timespec\fP ϼ˼褦˥ʥä٤ġ
.PP
.nf
struct timespec {
    long tv_sec;    /* seconds */
    long tv_nsec;   /* nanoseconds */
};
.fi
.RE
.TP
\fIsigmask\fP
ΰ \fBselect\fP μ¹˵Ĥ
ʥνݻ
.RB ( sigaddset (3)

.BR sigprocmask (2)
򸫤)ˤ NULL ϤȤǤ
ξϤδؿȤФȤ˵ĥʥνѹʤ
θ \fBselect\fP Ȥ礦Ʊ褦˿񤦡
.SH ʥȥǡ٥ȤȤ߹碌
ե롦ǥץ顢ǡǤʤʥԤȤˤ
.B pselect
Ȥɬפ롣ʥ򥤥٥ȤȤƼץϡ
񥷥ʥϥɥ򥰥Хʥե饰ΩƤ뤿˻Ȥ
ΥХʥե饰ϡ
Υ٥ȤץΥᥤ롼פ
ʤФʤʤȤ򼨤
ʥ
.B select
 (ޤ
.B pselect
) 
.B errno

.B EINTR
򥻥åȤ뤳Ȥˤʤ롣
ʥ뤬ץΥᥤ롼פǽ뤿ˤϤưԲķǡ
줬ʤ
.B select
ϱʱ˥֥åĤŤ뤳Ȥˤʤ롣
ơᥤ롼פΤɤˤΥХե饰å
ʸȤ褦Dz桹ʤФʤʤ
֥ʥ뤬ʸθ塢
.B select
夷ɤʤΤ
ϡ֤
.B select
ϡȤԤΥ٥ȤäȤƤ⡢
ʱ (block) פǤ롣
ζ֤
.B pselect
ˤäƲǤ롣
.B pselect
ϡʬȤʳǤϼʤʥޥ
Τ˻ѤǤ롣
㤨СȤʤäƤ륤٥Ȥҥץνλ (exit) ξͤ褦
ᥤ롼פϤޤˡ
.B SIGCHLD

.B sigprocmask
ǥ֥å롣
.B pselect
Ǥ
.B SIGCHLD
򡢤ȤȤΥʥޥȤäͭˤΤ
ΥץϼΤ褦ˤʤ롣
.PP
.nf
int child_events = 0;

void child_sig_handler (int x) {
    child_events++;
    signal (SIGCHLD, child_sig_handler);
}

int main (int argc, char **argv) {
    sigset_t sigmask, orig_sigmask;

    sigemptyset (&sigmask);
    sigaddset (&sigmask, SIGCHLD);
    sigprocmask (SIG_BLOCK, &sigmask,
                                &orig_sigmask);

    signal (SIGCHLD, child_sig_handler);

    for (;;) { /* main loop */
        for (; child_events > 0; child_events--) {
            /* do event work here */
        }
        r = pselect (nfds, &rd, &wr, &er, 0, &orig_sigmask);

        /* main body of program */
    }
}
.fi
.PP
嵭
.B pselect
ϼ֤뤳ȤǤ롣
.PP
.nf
        sigprocmask (SIG_BLOCK, &orig_sigmask, 0);
        r = select (nfds, &rd, &wr, &er, 0);
        sigprocmask (SIG_BLOCK, &sigmask, 0);
.fi
.PP
ξˤϡ
.B sigprocmask

.B select
δ֤˥ʥ뤬夹ǽĤ롣
Τ褦ˤϡʤȤͭ»֤ timeout ꤷơ
ץ֥åʤ褦ˤΤǤ롣
ߤ glibc Ϥ餯Τ褦ư롣
Linux ͥϤޤͥƥ֤
.B pselect
ƥॳäƤʤΤǡޥˤʤäƤޤΤ
ΤȤ¿ΤǤϤʤ
.\"nakano äƤ뤫?
.PP
.SH 
ºݤΤȤ
.B select
ϲʤΤ
ǥץϹʤȤɤ߽񤭤Ǥ󤸤ʤΡ
.B select
νפʤȤϡʣΥǥץƱ˴ƻǤ
ʤưʤХץŬڤ˥꡼׾֤˰ܹԤȤˤΤ
.B select
ѤСʣΥѥפ䥽åȤƱ˰ʤ餳줬Ԥ롣
Unix ץޤϡ
ʣΥե롦ǥץƱ˰ͤФʤ餺
ǡήϴַŪǤ롢Ȥɤв񤦡
ñ
.B read

.B write
Υ󥹤ǤϡΥΤɤ줫
ե롦ǥץΥǡԤäƥ֥åƤꡢ
¾Υե롦ǥץˤϥǡ夷ƤΤ˻Ȥʤ
ȤȤˤʤäƤޤ
.B select
Ϥξ˸Ūн褹롣

.B select
 man ڡΤä
.B select
θŵŪ򼨤

.nf
#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int
main(void) {
    fd_set rfds;
    struct timeval tv;
    int retval;

    /* Watch stdin (fd 0) to see when it has input. */
    FD_ZERO(&rfds);
    FD_SET(0, &rfds);
    /* Wait up to five seconds. */
    tv.tv_sec = 5;
    tv.tv_usec = 0;

    retval = select(1, &rfds, NULL, NULL, &tv);
    /* Don't rely on the value of tv now! */

    if (retval == -1)
        perror("select()");
    else if (retval)
        printf("Data is available now.\\n");
        /* FD_ISSET(0, &rfds) will be true. */
    else
        printf("No data within five seconds.\\n");

    exit(0);
}
.fi
.SH ݡȥեǥ󥰤
Ǥ
.B select
򼨤ɤҲ𤹤롣
ʲΥꥹȤϡ TCP ݡȤ̤ΥݡȤإեɤԤ
TCP եɥץǤ롣
.PP
.nf
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <string.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

static int forward_port;

#undef max
#define max(x,y) ((x) > (y) ? (x) : (y))

static int listen_socket (int listen_port) {
    struct sockaddr_in a;
    int s;
    int yes;
    if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
        perror ("socket");
        return -1;
    }
    yes = 1;
    if (setsockopt
        (s, SOL_SOCKET, SO_REUSEADDR,
         (char *) &yes, sizeof (yes)) < 0) {
        perror ("setsockopt");
        close (s);
        return -1;
    }
    memset (&a, 0, sizeof (a));
    a.sin_port = htons (listen_port);
    a.sin_family = AF_INET;
    if (bind
        (s, (struct sockaddr *) &a, sizeof (a)) < 0) {
        perror ("bind");
        close (s);
        return -1;
    }
    printf ("accepting connections on port %d\\n",
            (int) listen_port);
    listen (s, 10);
    return s;
}

static int connect_socket (int connect_port,
                           char *address) {
    struct sockaddr_in a;
    int s;
    if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
        perror ("socket");
        close (s);
        return -1;
    }

    memset (&a, 0, sizeof (a));
    a.sin_port = htons (connect_port);
    a.sin_family = AF_INET;

    if (!inet_aton
        (address,
         (struct in_addr *) &a.sin_addr.s_addr)) {
        perror ("bad IP address format");
        close (s);
        return -1;
    }

    if (connect
        (s, (struct sockaddr *) &a,
         sizeof (a)) < 0) {
        perror ("connect()");
        shutdown (s, SHUT_RDWR);
        close (s);
        return -1;
    }
    return s;
}

#define SHUT_FD1 {                      \\
        if (fd1 >= 0) {                 \\
            shutdown (fd1, SHUT_RDWR);  \\
            close (fd1);                \\
            fd1 = -1;                   \\
        }                               \\
    }

#define SHUT_FD2 {                      \\
        if (fd2 >= 0) {                 \\
            shutdown (fd2, SHUT_RDWR);  \\
            close (fd2);                \\
            fd2 = -1;                   \\
        }                               \\
    }

#define BUF_SIZE 1024

int main (int argc, char **argv) {
    int h;
    int fd1 = -1, fd2 = -1;
    char buf1[BUF_SIZE], buf2[BUF_SIZE];
    int buf1_avail, buf1_written;
    int buf2_avail, buf2_written;

    if (argc != 4) {
        fprintf (stderr,
                 "Usage\\n\\tfwd <listen-port> \\
<forward-to-port> <forward-to-ip-address>\\n");
        exit (1);
    }

    signal (SIGPIPE, SIG_IGN);

    forward_port = atoi (argv[2]);

    h = listen_socket (atoi (argv[1]));
    if (h < 0)
        exit (1);

    for (;;) {
        int r, nfds = 0;
        fd_set rd, wr, er;
        FD_ZERO (&rd);
        FD_ZERO (&wr);
        FD_ZERO (&er);
        FD_SET (h, &rd);
        nfds = max (nfds, h);
        if (fd1 > 0 && buf1_avail < BUF_SIZE) {
            FD_SET (fd1, &rd);
            nfds = max (nfds, fd1);
        }
        if (fd2 > 0 && buf2_avail < BUF_SIZE) {
            FD_SET (fd2, &rd);
            nfds = max (nfds, fd2);
        }
        if (fd1 > 0
            && buf2_avail - buf2_written > 0) {
            FD_SET (fd1, &wr);
            nfds = max (nfds, fd1);
        }
        if (fd2 > 0
            && buf1_avail - buf1_written > 0) {
            FD_SET (fd2, &wr);
            nfds = max (nfds, fd2);
        }
        if (fd1 > 0) {
            FD_SET (fd1, &er);
            nfds = max (nfds, fd1);
        }
        if (fd2 > 0) {
            FD_SET (fd2, &er);
            nfds = max (nfds, fd2);
        }

        r = select (nfds + 1, &rd, &wr, &er, NULL);

        if (r == -1 && errno == EINTR)
            continue;
        if (r < 0) {
            perror ("select()");
            exit (1);
        }
        if (FD_ISSET (h, &rd)) {
            unsigned int l;
            struct sockaddr_in client_address;
            memset (&client_address, 0, l =
                    sizeof (client_address));
            r = accept (h, (struct sockaddr *)
                        &client_address, &l);
            if (r < 0) {
                perror ("accept()");
            } else {
                SHUT_FD1;
                SHUT_FD2;
                buf1_avail = buf1_written = 0;
                buf2_avail = buf2_written = 0;
                fd1 = r;
                fd2 =
                    connect_socket (forward_port,
                                    argv[3]);
                if (fd2 < 0) {
                    SHUT_FD1;
                } else
                    printf ("connect from %s\\n",
                            inet_ntoa
                            (client_address.sin_addr));
            }
        }
/* NB: read oob data before normal reads */
        if (fd1 > 0)
            if (FD_ISSET (fd1, &er)) {
                char c;
                errno = 0;
                r = recv (fd1, &c, 1, MSG_OOB);
                if (r < 1) {
                    SHUT_FD1;
                } else
                    send (fd2, &c, 1, MSG_OOB);
            }
        if (fd2 > 0)
            if (FD_ISSET (fd2, &er)) {
                char c;
                errno = 0;
                r = recv (fd2, &c, 1, MSG_OOB);
                if (r < 1) {
                    SHUT_FD1;
                } else
                    send (fd1, &c, 1, MSG_OOB);
            }
        if (fd1 > 0)
            if (FD_ISSET (fd1, &rd)) {
                r =
                    read (fd1, buf1 + buf1_avail,
                          BUF_SIZE - buf1_avail);
                if (r < 1) {
                    SHUT_FD1;
                } else
                    buf1_avail += r;
            }
        if (fd2 > 0)
            if (FD_ISSET (fd2, &rd)) {
                r =
                    read (fd2, buf2 + buf2_avail,
                          BUF_SIZE - buf2_avail);
                if (r < 1) {
                    SHUT_FD2;
                } else
                    buf2_avail += r;
            }
        if (fd1 > 0)
            if (FD_ISSET (fd1, &wr)) {
                r =
                    write (fd1,
                           buf2 + buf2_written,
                           buf2_avail -
                           buf2_written);
                if (r < 1) {
                    SHUT_FD1;
                } else
                    buf2_written += r;
            }
        if (fd2 > 0)
            if (FD_ISSET (fd2, &wr)) {
                r =
                    write (fd2,
                           buf1 + buf1_written,
                           buf1_avail -
                           buf1_written);
                if (r < 1) {
                    SHUT_FD2;
                } else
                    buf1_written += r;
            }
/* check if write data has caught read data */
        if (buf1_written == buf1_avail)
            buf1_written = buf1_avail = 0;
        if (buf2_written == buf2_avail)
            buf2_written = buf2_avail = 0;
/* one side has closed the connection, keep
   writing to the other side until empty */
        if (fd1 < 0
            && buf1_avail - buf1_written == 0) {
            SHUT_FD2;
        }
        if (fd2 < 0
            && buf2_avail - buf2_written == 0) {
            SHUT_FD1;
        }
    }
    return 0;
}
.fi
.PP
嵭ΥץϡۤȤɤμ TCP ³եɤ롣
.B telnet
ФˤäѤ OOB ʥǡⰷ롣
ΥץϡǡեƱȤ
䤳Ǥ롣
.B fork()
Ȥäơƥȥ꡼ऴȤѤΥåɤѤۤΨŪ
Ȥͤ⤤뤫⤷ʤϹͤƤꤺäȤ䤳
뤤
.B ioctl()
Ȥä֥å IO 򥻥åȤɤȤǥ⤢
ˤºݤˤ꤬ꡢΨŪʥॢȤ
ɤƤɬפˤʤäƤޤ

Υץϰ٤ˤҤȤİʾƱ³򰷤ȤϤǤʤ
ͤ˳ĥΤϴñǡХåեΥ󥯥ꥹȤ
(³ȤˤҤȤĤ) ȤФ褤
ΤΤǤϡ³ȸŤ³Ƥޤ
.SH SELECT 
.B select
ȤȤ¿οͤϡ򤷤ˤ񤤤˽Ф路
̤ϥݡ֥Ǥʤ (褯Ƥ⥮ꥮ) ʤäƤޤ
㤨о嵭Υץϡ
˴ޤޤե롦ǥץ֥å⡼ɤ
.RB ( ioctl (2)
) ʤƤ⡢ɤˤ֥åʤ褦դƽ񤫤Ƥ롣
̯ʴְ㤤ˤäơ
.B select
Ȥϴñ˼Ƥޤ
ǤǤϡ
.B select
ȤȤդ٤׻ꥹȤ褦Ȼפ
.TP
\fB1.\fP
.B select
ȤȤϡॢȤꤹ٤Ǥʤ
ǡ̵Ȥˤϡ
ʤΥץˤϲ⤹뤳Ȥ̵ϤǤ롣
ॢȤ˰¸ɤ̾ݡ֥ǤϤʤʤꡢ
ǥХå񤷤ʤ롣
.TP
\fB2.\fP
Ҥ褦ˡ
ΨŪʥץ񤯤ˤ
.I nfds
ͤŬڤ˷׻ͿʤФʤʤ
.TP
\fB3.\fP
.B select
νλ˷̤åơ
ŬڤбĤΤʤե롦ǥץϡ
ɤνˤäƤϤʤʤ
Υ롼⸫衣
.TP
\fB4.\fP
.B select
֤äˤϡ
ƤνƤΥե롦ǥץ\fBåʤФʤʤ\fP
񤭹߲ǽʥե롦ǥץ٤Ƥ\fB񤭹\fP
ɤ߼ǽʥե롦ǥץ٤Ƥ
\fBɤ߼\fPԤʤФʤʤ¾Ʊ
.TP
\fB5.\fP
.BR read() ", " recv() ", " write() ", " send()
Ȥäؿϡ餬׵ᤷǡ̤ɤ߽񤭤ɬפ\fIʤ\fP
⤷̤ɤ߽񤭤ʤ顢ϥȥեå٤
ȥ꡼ब®ξϾȤϸ¤ʤ
δؿĥäƤ 1 ХȤǤʤ褦ʾ
θƤʤФʤʤ
.TP
\fB6.\fP
ǡ̤ȤϤäȤ狼äƤơ
٤ 1 ХȤɤ߽񤭤褦ʤȤϤƤϤʤʤ
ХåեεΥǡޤȤɤ߽񤭤ʤȡ
˸Ψ嵭ǤϥХåե 1024 ХȤˤƤ뤬
Υʬ LAN Υѥåȥ
Ʊ礭ˤΤϴñˤǤ
.TP
\fB7.\fP
.BR read() ", " recv() ", " write() ", " send()
ʤɤδؿ
.B select()
 errno 
.B EINTR "  " EAGAIN
.RB ( EWOULDBLOCK )
ˤ \-1 ֤Ȥ뤬ϥ顼ǤϤʤ
η̤Ŭڤ˽ƤʤФʤʤ (嵭ǤϤƤʤ)
񤤤Ƥץ˥ʥͽ꤬ʤС
.B EINTR
뤳ȤϤޤͤʤ
񤤤Ƥץब֥å IO 򥻥åȤƤʤС
.B EAGAIN
뤳ȤϤʤǤʤ
ʤСΥ顼θɬפ롣
.TP
\fB8.\fP
褷ơĹ 0 ΥХåեꤷ
\fBread()\fP, \fBrecv()\fP, \fBwrite()\fP, \fBsend()\fP
ƤӽФƤϤʤʤ
.TP
\fB9.\fP
\fB7.\fP Ǽ
\fBread()\fP, \fBrecv()\fP, \fBwrite()\fP, \fBsend()\fP
ʤɤδؿϡ
顼Ǥʤз褷 1 꾮֤ͤʤ
㤨С¾üǤѥפФ
\fBread()\fP Ԥȡ0 ֤ (end-of-file 顼Ʊ) 
\fI\fP 0 ֤Τϰ٤Ǥ롣
(ʹߤ read  write Ԥä \-1 ֤)
δؿ 0  \-1 ֤顢
Υǥץ select ٤ϤƤ\fIʤʤ\fP
嵭ǤϡϤΥǥץ򤿤˥
ˤ \-1 򥻥åȤơ
줬˴ޤޤ³Τʤ褦ˤƤ롣
.TP
\fB10.\fP
ॢȤͤ
.B select
Ƥ֤Ӥ˽٤Ǥ롣
OS ˤäƤ timeout ¤Τѹ礬뤫Ǥ롣

.B pselect
ϡʬ timeout ¤Τѹ뤳ȤϤʤ
.TP
\fB11.\fP
ʹȤǤϡWindows Υåؤ
OOB ǡʤ餷
ޤե롦ǥץåȤƤʤ褦
.B select
ʤ餷
ե롦ǥץꤷʤ timeout Ȥϡ
1 ðʲ٤ǥץ򥹥꡼פˤˡʤΤ
(³򸫤)
.SH USLEEP ߥ졼
\fBusleep\fP ؿʤƥǤϡ
\fBselect\fP ͭ¤ timeout ꤷ
ե롦ǥץͿʤФؤǤ롣
ʲΤ褦ˤ롣
.PP
.nf
    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = 200000;  /* 0.2 seconds */
    select (0, NULL, NULL, NULL, &tv);
.fi
.PP
줬ưݾڤƤΤ Unix ƥ˸¤롣
.SH ֤
ȡ
.B select
ϥե롦ǥץˤޤ¸ߤƤ
ե롦ǥץ֤

.B select
ॢȤȡե롦ǥץϤ٤ƶˤʤ٤Ǥ
(ʤʤƥ⤢)֤ͤɬ 0 ˤʤ롣

֤ͤ \-1 ξϥ顼̣
.B errno
Ŭڤ˥åȤ롣顼ä¿Ǥϡ
֤줿 timeout ¤ΤƤ̤ȤʤäƤΤǡ
Ȥ٤ǤϤʤ

.B pselect
Ϸ褷
.I ntimeout
ѹʤ
.SH 顼
.TP
\fBEBADF\fP
ʥե롦ǥץޤޤƤ롣
Υ顼ϡ
.B close
ѤߤΥե롦ǥץ䡢
餫Υ顼Ƥե롦ǥץ
­ȤˤäƵ뤳Ȥ¿
äɤ߽񤭤κݤ˥顼֤褦ʥե롦ǥץ
˲äʤۤɤ
.TP
\fBEINTR\fP
.B SIGINT

.B SIGCHLD
Τ褦ʳߥʥ򥭥å
ξϥե롦ǥץƹۤƥȥ饤ʤФʤʤ
.TP
\fBEINVAL\fP
.I nfds
ξ硢ޤ \fIutimeout\fP  \fIntimeout\fP ̵ͤ
ꤵ줿˵롣
.TP
\fBENOMEM\fP
ǤΥꥢμԡ
.SH 
Ū˸äơåȤ򥵥ݡȤƤΥڥ졼ƥ󥰥ƥ
.B select
⥵ݡȤ롣
.B select
ϱΤ褦ʤΤǡ¿˻ȤʤȹͤƤͤ⤤褦
ºݤˤϡ
.B select
ȤʤȤΤʣˤʤäƤޤץब¿Τ
.B select
ѤС
ץޤޤǥåɡեIPCʥ롢
궦ͭ¾ʤˡʤɤǤФȤƤ¿꤬
ݡ֥뤫ĸΨŪ˲Ǥ롣
.B pselect
Ϥ꿷ؿǤꡢ٤
.B select
꾯ʤ
.PP
.BR poll (2)
ƥॳ \fBselect\fP ƱǽĤ
\fBselect\fP 褯ʬʤ̯ưʤ
ޤܿˤ \fBselect\fP 롣
.SH 
4.4BSD (\fBselect\fP ؿ 4.2BSD ǺǽƳ줿)
BSD åؤΥ򥵥ݡȤƤ BSD ƥ
(System V Ϥޤޤ) Ȥδ֤Ǥܿ롣 System V ϤǤ
 timeout ѿ exit ˥åȤ뤬
BSD ϤǤϤǤʤΤդ뤳ȡ
.PP
.B select
ؿ IEEE Std 1003.1g-2000 (POSIX.1g) Ƥ롣
ޤ glibc2.1 ʹߤ¸ߤ롣
glibc2.0 ˤƱ̾δؿ¸ߤ뤬

.I sigmask
ѥ᡼ʤ
.SH Ϣ
.BR accept (2),
.BR connect (2),
.BR ioctl (2),
.BR poll (2),
.BR read (2),
.BR recv (2),
.BR select (2),
.BR send (2),
.BR sigprocmask (2),
.BR write (2),
.BR sigaddset (3),
.BR sigdelset (3),
.BR sigemptyset (3),
.BR sigfillset (3),
.BR sigismember (3)
.SH 
 man ڡ Paul Sheer 񤤤