LINUX网络编程（fork、select、epoll三种模式）
使用了fork、select、epoll三种socket服务器工作模式，客户端向服务端发送任何数据，服务端再原样返回给客户端，本文的目的只为加深偶的记忆。
fork:每accept到一个socket之后，开启一个子进程来负责收发处理工作。
select:监控文件描述符事件
epoll:监控文件描述符事件，比select性能优异，可最大支持2W个连接，有死连接时处理能力高
文末附注了SOCKET的一些常见错误标识
-------------------------- fork.cpp --------------------------
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <string>
#include <stdexcept>
#include <iostream>
#include <sys/ioctl.h>
#define SERVER_PORT 8888
#define BUFFER_LENGTH 1024
using namespace std;
class SocketException : public std::logic_error
{
public:
SocketException(const std::string& what) throw ()
: std::logic_error(what) {};
};
int SocketRead(int& fd, std::string& strValue)
{
// 每次只读取一个字节
int nRead = 1;
auto_ptr<char> apBuf(new char[nRead]);
int r = read(fd, apBuf.get(), nRead) ;
if (0 < r)
{
strValue.assign(apBuf.get(), r);
}
return r;
}
int SocketWrite(int& fd, const char* pBuf, int nBufLen)
{
int nWrite = 0;
int nError = -1;
/*
SIGPIPE：sent to a process when it attempts to write to a pipe without a process connected to the other end. The symbolic constant for SIGPIPE is defined in the header file signal.h. Symbolic signal names are used because signal numbers can vary across platforms.
*/
// SIG_IGN:忽略信号
sighandler_t sh = signal(SIGPIPE, SIG_IGN);
while (nWrite < nBufLen)
{
nError = send(fd, pBuf + nWrite, nBufLen - nWrite, 0);
if (0 > nError)
{
perror(strerror(errno));
// 见文末
if (nError == EINTR) continue;
if (nError == EPIPE)
{
close(fd);
}
// 恢复信号
signal(SIGPIPE, sh);
throw SocketException(string("SocketWrite error, ") + strerror(errno));
}
else if (0 == nError)
{
signal(SIGPIPE, sh);
throw SocketException(string("SocketWrite error, ") + strerror(errno));
}
else
{
nWrite += nError;
}
}
signal(SIGPIPE, sh);
return nError;
}
void SetOption(int s, int level, int optname, const void *optval, socklen_t optlen)
{
if (setsockopt(s, level, optname, optval, optlen) < 0)
{
perror(strerror(errno));
}
}
int main(int argc, char*argv[])
{
int fdServer = -1;
int fdClient = -1;
int nStatus = -1;
pid_t pid = 0;
int nSockAddrLen = sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
struct sockaddr_in addrSocket;
bzero(&addrServer, sizeof(struct sockaddr_in));
bzero(&addrSocket, sizeof(struct sockaddr_in));
if(-1 == (fdServer = socket(AF_INET, SOCK_STREAM, 0)))
{
perror(strerror(errno));
exit(-1);
}
int nReuseAddr = 1;
SetOption(fdServer, SOL_SOCKET, SO_REUSEADDR, &nReuseAddr, sizeof(int));
addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
addrServer.sin_addr.s_addr = INADDR_ANY;
if (-1 == bind(fdServer, (struct sockaddr *)&addrServer, sizeof(struct sockaddr)))
{
perror(strerror(errno));
exit(-1);
}
if (-1 == listen(fdServer, 128))
{
perror(strerror(errno));
exit(-1);
}
while (true)
{
if ((fdClient = accept(fdServer, (struct sockaddr *)&addrSocket, (socklen_t*)&nSockAddrLen)) < 0)
{
perror(strerror(errno));
exit(-1);
}
printf("client address:%s\t port:%d\r\n", inet_ntoa(addrSocket.sin_addr), ntohs(addrSocket.sin_port));
if ((pid = fork()) < 0)
{
perror(strerror(errno));
exit(-1);
}
else if (0 == pid) /* clild */
{
while (true)
{
try
{
std::string strValue;
if(0 < SocketRead(fdClient, strValue))
{
SocketWrite(fdClient, strValue.c_str(), strValue.length());
}
else
{
close(fdClient);
}
// 要有延时，不然CPU使用率很高
usleep(10);
}
catch(const SocketException& e)
{
cerr << e.what() << endl;
close(fdClient);
break;
}
}
}
else /* parent */
{
close(fdClient);
}
}
return 0;
}
select()详述
select()机制中提供一fd_set的数据结构，实际上是一long类型的数组，每一个数组元素都能与一打开的文件句柄(不管是socket句柄，还是其他文件或命名管道或设备句柄)建立联系，建立联系的工作由程序员完成，当调用select()时，由内核根据IO状态修改fe_set的内容，由此来通知执行了select()的进程哪一socket或文件可读。
多端口复用函数select在调用前要首先设置监听的端口数目，FD_ZERO是清空端口集，FD_SET是设置端口集。
select()函数常常用在用一个进程监听多个服务器端socket。
有时，select()也被当作延时函数使用。sleep()延时会释放CPU，select()的话，可以在占用CPU的情况下延时。
select()函数主要是建立在fd_set类型的基础上的。fd_set(它比较重要所以先介绍一下)是一组文件描述字(fd)的集合，它用一位来表示一个fd(下面会仔细介绍)，对于fd_set类型通过下面四个宏来操作：
fd_set set;
FD_ZERO(&set); /*将set清零使集合中不含任何fd*/
FD_SET(fd, &set); /*将fd加入set集合*/
FD_CLR(fd, &set); /*将fd从set集合中清除*/
FD_ISSET(fd, &set); /*测试fd是否在set集合中*/
过去，一个fd_set通常只能包含<32的fd(文件描述字)，因为fd_set其实只用了一个32位矢量来表示fd; 现在，UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE，它是数据类型fd_set的描述字数量，其值通常是1024，这样就能表示<1024的fd。根据fd_set的位矢量实现，我们可以重新理解操作fd_set的四个宏：
fd_set set;
FD_ZERO(&set); /*将set的所有位置0，如set在内存中占8位则将set置为00000000*/
FD_SET(0, &set); /*将set的第0位置1，如set原来是00000000，则现在变为100000000，这样fd==1的文件描述字就被加进set中了*/
FD_CLR(4, &set); /*将set的第4位置0，如set原来是10001000，则现在变为10000000，这样fd==4的文件描述字就被从set中清除了*/
FD_ISSET(5, &set); /*测试set的第5位是否为1，如果原来set是10000100，则返回非零，表明fd==5的文件描述符在set中，否则返回0*/
注意：fd的最大值必须<FD_SETSIZE。
select函数的接口比较简单：
int select(int nfds, fd_set* readset, fd_set* writeset, fe_set* exceptset, struct timeval* timeout);
功能：
测试指定的fd可读？可写？有异常条件待处理？
参数：
nfds： 需要检查的文件描述字个数(即检查到fd_set的第几位)，数值应该比三组fd_set中所含的最大fd值更大，一般设为三组fd_set中所含的最大fd值加1(如在readset, writeset, exceptset中所含最大的fd为5，则nfds＝6，因为fd是从0开始的 )。设这个值是为了提高效率，使函数不必检查fd_set的所有1024位。
readset： 用来检查可读性的一组文件描述字。
writeset： 用来检查可写性的一组文件描述字。
exceptset： 用来检查是否有异常条件出现的文件描述字。(注：错误不包括在异常条件之内)
timeout： 有三种可能：
1. timeout = NULL (阻塞：直到有一个fd位被置为1函数才返回)
2. timeout所指向的结构设为非零时间(等待固定时间：有一个fd位被置为1或者时间耗尽，函数均返回)
3. timeout所指向的结构，时间设为0(非阻塞：函数检查完每一个fd后立即返回)
返回值：返回对应位仍然为1的fd的总数。
Remark：
三组fd_set均将某些fd位置0，只有那些可读，可写以及有异常条件待处理的fd位仍然为1。
使用select函数的过程一般是：
先调用宏FD_ZERO将指定的fd_set清零，然后调用宏FD_SET将需要测试的fd加入fd_set，接着调用函数select测试fd_set中的所有fd，最后用宏FD_ISSET检查某个fd在函数select调用后，相应位是否仍然为1。
以下是一个测试单个文件描述字可读性的例子：
int isready(int fd)
{
int rc;
fd_set fds;
struct timeval tv;
FD_ZERO(&fds);
FD_SET(fd, &fds);
tv.tv_sec = tv.tv_usec = 0;
rc = select(fd+1, &fds, NULL, NULL, &tv);
if( rc<0 ) //error
return -1;
return FD_ISSET(fd, &fds) ? 1: 0;
}
下面还有一个复杂一些的应用：
//这段代码将指定测试Socket的描述字的可读可写性，因为Socket使用的也是fd
unit32 SocketWait(TSocket* s, bool rd, bool wr, unit32 timems)
{
fd_set rfds, wfds;
#ifdef _WIN32
TIMEVAL tv;
#else
struct timeval tv;
#endif /*_WIN32*/
FD_ZERO(&rfds);
FD_ZERO(&wfds);
if(rd) //TRUE
FD_SET(*s, &rfds); //添加要测试的描述字
if(wr)
FD_SET(*s, &wfds);
tv.tv_sec = timems/1000; //seconds
tv.tv_usec = timems%1000; //ms
for(;;) //如果errno＝＝EINTR，反复测试缓冲区的可读性
switch(select((*s)+1, &fds, &wfds, NULL, (timems==TIME_INFINITE?NULL:&tv))) //测试在规定的时间内套接字接口接收缓冲区是否有数据可读
{
// 0——超时, -1——出错
case 0: /*time out*/
return 0;
case (-1): /*socket error*/
if( SocketError()==EINTR )
break;
return 0; //有错但不是EINTR
default:
if(FD_ISSET(*s, &rfds)) //如果s是fds中的一员返回非0，否则返回0
return 1;
if(FD_ISSET(*s, &wfds))
rerun 2;
return 0;
};
}
文章出处：http://jiaxingkui123.blog.163.com/blog/static/8756468420081111102917528/
-------------------------- select.cpp --------------------------
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>
#include <iostream>
#include <vector>
#include <arpa/inet.h>
#define SERVER_PORT 8888
#define NUM_MON 5
#define NUM_BUFFER 1024
#include <errno.h>
using namespace std;
void SetOption(int s, int level, int optname, const void *optval, socklen_t optlen)
{
if (setsockopt(s, level, optname, optval, optlen) < 0)
{
perror(strerror(errno));
}
}
int main(int argc, char*argv[])
{
int fdServer = -1;
int fdClient = -1;
int fdMax = -1;
int nRead = 0;
char buf[NUM_BUFFER];
int nSockAddrLen = sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
struct sockaddr_in addrSocket;
bzero(&addrServer, sizeof(struct sockaddr_in));
bzero(&addrSocket, sizeof(struct sockaddr_in));
int fdBuf[NUM_MON];
memset(fdBuf, -1, sizeof(fdBuf));
// 被监控的描述符集合
fd_set fsMon;
// 事件的描述符集合
fd_set fsRead;
FD_ZERO(&fsMon);
FD_ZERO(&fsRead);
if(-1 == (fdServer = socket(AF_INET, SOCK_STREAM, 0)))
{
perror(strerror(errno));
exit(-1);
}
int nReuseAddr = 1;
SetOption(fdServer, SOL_SOCKET, SO_REUSEADDR, &nReuseAddr, sizeof(int));
addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
addrServer.sin_addr.s_addr = INADDR_ANY;
if (-1 == bind(fdServer, (struct sockaddr *)&addrServer, sizeof(struct sockaddr)))
{
perror(strerror(errno));
exit(-1);
}
if (-1 == listen(fdServer, 128))
{
perror(strerror(errno));
exit(-1);
}
// 服务端是被监控对象之一
FD_SET(fdServer, &fsMon);
fdMax = fdServer;
while (true)
{
fsRead = fsMon;
switch(select(fdMax + 1, &fsRead, NULL, NULL, NULL))
{
case -1:
perror(strerror(errno));
exit(-1);
case 0:
perror("timeout");
continue;
default:
break;
}
// 是否为fdServer的可读事件
if (FD_ISSET(fdServer, &fsRead))
{
if (0 > (fdClient = accept(fdServer, (struct sockaddr *)&addrSocket, (socklen_t*)&nSockAddrLen)))
{
perror(strerror(errno));
exit(-1);
}
// socket加入fdBuf, fdBuf中是保存的所有socket的集合
for (int i = 0; i < NUM_MON; ++i)
{
if(-1 == fdBuf[i])
{
fdBuf[i] = fdClient;
break;
}
}
// 把socket加入监控集合
FD_SET(fdClient, &fsMon) ;
fdMax = max(fdMax, fdClient);
continue;
}
for (int i = 0; i < NUM_MON; ++i)
{
if (-1 == fdBuf[i]) continue;
if (!FD_ISSET(fdBuf[i], &fsMon)) continue;
// 缓冲区中，是否有数据可读
ioctl(fdBuf[i], FIONREAD, &nRead);
if (0 >= nRead)
{
// 非可读
FD_CLR(fdBuf[i], &fsMon);
continue;
}
read(fdBuf[i], buf, nRead) ;
write(fdBuf[i], buf, nRead) ;
}
}
}
-------------------------- epoll.cpp --------------------------
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <stdexcept>
#include <fcntl.h>
#include <iostream>
using namespace std;
#define SERVER_PORT 8888
class SocketException : public std::logic_error
{
public:
SocketException(const std::string& what) throw ()
: std::logic_error(what) {};
};
int SocketRead(int& fd, std::string& strValue)
{
// 缓冲区中，是否有数据可读
int nRead = 0;
ioctl(fd, FIONREAD, &nRead);
if (nRead > 0)
{
auto_ptr<char> apBuf(new char[nRead]);
read(fd, apBuf.get(), nRead) ;
strValue.assign(apBuf.get(), nRead);
}
else
{
cout << nRead << endl;
close(fd);
}
return nRead;
}
int SocketWrite(int& fd, const char* pBuf, int nBufLen)
{
// 参见fork.cpp
int nWrite = 0;
int nError = -1;
sighandler_t sh = signal(SIGPIPE, SIG_IGN);
while (nWrite < nBufLen)
{
nError = send(fd, pBuf + nWrite, nBufLen - nWrite, 0);
if (0 > nError)
{
perror(strerror(errno));
if (nError == EINTR) continue;
if (nError == EPIPE)
{
close(fd);
}
signal(SIGPIPE, sh);
throw SocketException(string("SocketWrite error, ") + strerror(errno));
}
else if (0 == nError)
{
// out pipe is closed
signal(SIGPIPE, sh);
throw SocketException(string("SocketWrite error, ") + strerror(errno));
}
else
{
nWrite += nError;
}
}
signal(SIGPIPE, sh);
return nError;
}
void SetOption(int s, int level, int optname, const void *optval, socklen_t optlen)
{
if (setsockopt(s, level, optname, optval, optlen) < 0)
{
perror(strerror(errno));
}
}
// 设置socket为非阻塞式
void SetNonBlocking(int fd)
{
int flags = fcntl(fd, F_GETFL);
flags |= O_NONBLOCK;
fcntl(fd, F_SETFL, flags);
}
int main(int argc, char*argv[])
{
int nfds, epfd, fdServer, fdClient;
int maxevents = 1000;
struct epoll_event ev, *events;
epfd = epoll_create(128);
int nSockAddrLen = sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
struct sockaddr_in addrSocket;
bzero(&addrServer, sizeof(struct sockaddr_in));
bzero(&addrSocket, sizeof(struct sockaddr_in));
if(-1 == (fdServer = socket(AF_INET, SOCK_STREAM, 0)))
{
perror(strerror(errno));
exit(-1);
}
int nReuseAddr = 1;
SetOption(fdServer, SOL_SOCKET, SO_REUSEADDR, &nReuseAddr, sizeof(int));
addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
addrServer.sin_addr.s_addr = INADDR_ANY;
if (-1 == bind(fdServer, (struct sockaddr *)&addrServer, sizeof(struct sockaddr)))
{
perror(strerror(errno));
exit(-1);
}
// 监控对象fdServer
ev.data.fd = fdServer;
// 事件：边沿触发，IN事件
ev.events = EPOLLIN | EPOLLET;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, fdServer, &ev) < 0)
{
perror(strerror(errno));
exit(-1);
}
if (-1 == listen(fdServer, 64))
{
perror(strerror(errno));
exit(-1);
}
while(true)
{
nfds = epoll_wait(epfd, events, maxevents, -1);
if (0 > nfds)
{
cerr << "epoll_wait:" << strerror(errno) << endl;
}
for(int n = 0; n < nfds; ++n)
{
// 事件主体为服务端？
if(events[n].data.fd == fdServer)
{
fdClient = accept(fdServer, (struct sockaddr *)&addrSocket, (socklen_t*)&nSockAddrLen);
if(0 > fdClient)
{
perror(strerror(errno));
continue;
}
// 非阻塞式，咱们目标是，快点处理完来下一轮
SetNonBlocking(fdClient);
// socket加入监控列表
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = fdClient;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, fdClient, &ev) < 0)
{
cerr << "epoll set insertion error: fd=" << fdClient << endl;
return -1;
}
}
else
{
int nError = 0;
char buf[1024];
while(true)
{
nError = read(events[n].data.fd, buf, sizeof(buf));
cout << " read bytes:" << nError << endl;
if (-1 == nError)
{
perror(strerror(errno));
// 这些见文末说明
if (nError == EINTR) continue;
if (nError == EPIPE)
{
// 从监控列表中移除
epoll_ctl(epfd, EPOLL_CTL_DEL, events[n].data.fd, &ev);
close(events[n].data.fd);
break;
}
break;
}
else if (0 == nError)
{
// 从监控列表中移除
epoll_ctl(epfd, EPOLL_CTL_DEL, events[n].data.fd, &ev);
close(events[n].data.fd);
break;
}
SocketWrite(events[n].data.fd, buf, nError);
}
}
}
}
return 0;
}
---------------------- 文末 ------------------
EINTR、EPIPE、EAGAIN等参考 http://wenku.baidu.com/view/02a0cff34693daef5ef73d0f.html
转自 http://hi.baidu.com/yuanhuiyong/blog/item/ff4e8f26a46e0b6d35a80f7b.html