select()

由 kernel 注意某些 fd 是否 active（readable、writable 及有 error），有則 return 讓 application process 對 active 的 fd 做相應的處理。用 select() 可避免 application process 去 polling 看各個 socket 是否 active、浪費 CPU 資源。如果沒有 fd active、沒設 timeout、沒有 signal 打斷，select() 是 blocking。

正常狀況下 select() return 三個 fdset 共有多少 fd active。timeout 時 return 0。收到 signal return -1 且 errno 設為 EINTR，不會測試 fd 也不會修改 fd_set，所以不能用 fd 判斷是否 active。select() 之所以在被 signal 打斷時不修改 fd_set，是為了避免 select() 跟 signal handler 不斷修改同一個 flag 造成 infinite loop。例如 select() 發現某 flag 是 0 會將 flag 設為 1，而某個 signal handler 遇到 flag 是 1 又把 flag 設為 0，沒完沒了。

pselect() 可設定擋住哪些 signal，讓這些 signal 不打斷 pselect()。

Sample Code

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>
#include <cstdlib>
#include <errno.h>
#include <set>
#include <iostream>

#define MAXBUF 1000

using namespace std;

void run(int listenPort, int qlen);
int CreateListenSock(int listenPort, int qlen);

int main()
{
    run(8899, 5);
    return 0;
}

void run(int listenPort, int qlen)
{
    fd_set afdset, rfdset, wfdset, efdset;
    int listenfd = CreateListenSock(listenPort, qlen);
    int maxfd = listenfd;
    set<int> fds;
    bool bNeedWrite = false;

    FD_ZERO(&afdset); FD_ZERO(&rfdset); FD_ZERO(&wfdset); FD_ZERO(&efdset);
	FD_SET(listenfd, &afdset);

    fds.insert(listenfd);

    while (true)
    {
        int iActive = 0;
        struct timeval timeout;

        rfdset = afdset;
        efdset = afdset;

        if (bNeedWrite)
        {
            wfdset = afdset;
        }
        else
        {
            FD_ZERO(&wfdset);
        }

        timeout.tv_sec = 3;
		timeout.tv_usec = 0;
		
        if ((iActive = select(maxfd + 1, &rfdset, &wfdset, &efdset, &timeout)) == -1)
        {
            // handle error
            if (errno == EINTR)
            {
            }
            else
            {
            }
        }
        else
        {
            int iHandled = 0;
			set<int>::iterator fdIter = fds.begin();
            for (; fdIter != fds.end() && iHandled < iActive; ++fdIter)
            {
                int fd = *fdIter;

                if (FD_ISSET(fd, &rfdset))
                {
                    if (fd == listenfd)
                    {
                        // handle new connection
                        struct sockaddr_in cliaddr;
                        socklen_t cliaddrlen = sizeof(cliaddr);

                        bzero((char *)&cliaddr, sizeof(cliaddr));

                        int connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen);

                        fds.insert(connfd);
                        FD_SET(connfd, &afdset);
                        if (connfd > maxfd)
						{
							maxfd = connfd;
						}
                    }
                    else
                    {
                        // handle read
                        char readBuf[MAXBUF];
                        int iRead = 0;

                        bzero(readBuf, MAXBUF);

                        if ((iRead = read(fd, &readBuf, MAXBUF - 1)) > 0)
                        {
                            readBuf[iRead] = 0;
                        }
                        else if (iRead == 0)
                        {
                            close(fd);
                            FD_CLR(fd, &afdset);
                            fds.erase(fd);
                        }
                        else
                        {
                            // handle read error
                        }
                    }

                    iHandled++;
                }

                if (FD_ISSET(fd, &wfdset))
                {
                    // handle write
                    iHandled++;
                }

                if (FD_ISSET(fd, &efdset))
                {
                    // handle error
                    iHandled++;
                }
            }
        }
    }
}

int CreateListenSock(int listenPort, int qlen)
{
    struct sockaddr_in servAddr;
    int listenfd = -1;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
	{
        cerr << "Create socket failed" << endl;
        exit(1);
    }

    bzero((char *)&servAddr, sizeof(servAddr));
    servAddr.sin_family = AF_INET;
    servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servAddr.sin_port = htons(listenPort);

    if (bind(listenfd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) 
	{
        cerr << "Bind socket failed" << endl;
        exit(1);
    }

    listen(listenfd, qlen);

    return listenfd;
}