epoll案例

#include <stdio.h>
#include <string.h>
#include <errno.h>

#include <iostream>

#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>

#include <fcntl.h>
#include <unistd.h>

#include <sys/epoll.h>

#define MAX_EVENTS 1024

using namespace std;

static int setSocketNonBlock(const int socketFd)
{
int ret(0);

int flags = fcntl(socketFd, F_GETFL, 0);
if (-1 == flags)
{
cerr << "fcntl error" << endl;
return -1;
}

flags |= O_NONBLOCK;
ret = fcntl(socketFd, F_SETFL, flags);
if (-1 == ret)
{
cerr << "fcntl error" << endl;
return -1;
}

return 0;
}

static int setSocketLingerDisable(const int socketFd)
{
int ret(0);

struct linger lingerVal;
lingerVal.l_onoff = 1;
lingerVal.l_linger = 0;
ret = setsockopt(socketFd, SOL_SOCKET, SO_LINGER, &lingerVal, sizeof(struct linger));
if (0 != ret)
{
cerr << "setsockopt" << endl;
return -1;
}

return 0;
}

static int create_and_bind()
{
int ret(0);

struct addrinfo hints;
struct addrinfo * retAddr, * retNext;

memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = AI_PASSIVE;
ret = getaddrinfo(NULL, "8090", &hints, &retAddr);
if (0 != ret)
{
cerr << "getaddrinfo" << endl;
return -1;
}

int listenSocket(-1);

for (retNext = retAddr; retNext != NULL; retNext = retNext->ai_next)
{
//        char ipBuf[1024];
//        switch(retNext->ai_family)
//        {
//        case AF_INET:
//            inet_ntop(AF_INET, &((struct sockaddr_in *)(retNext->ai_addr))->sin_addr, ipBuf, sizeof(char[1024]));
//            break;
//        case AF_INET6:
//            inet_ntop(AF_INET6, &((struct sockaddr_in6 *)(retNext->ai_addr))->sin6_addr, ipBuf, sizeof(char[1024]));
//            break;
//        }
//        cout << "ipBuf: " << ipBuf << endl;

listenSocket = socket(retNext->ai_family, retNext->ai_socktype, retNext->ai_protocol);
if (-1 == listenSocket)
{
cerr << "socket error" << endl;
continue;
}

ret = bind(listenSocket, retNext->ai_addr, retNext->ai_addrlen);
if (0 != ret)
{
cerr << " bind error" << endl;
close(listenSocket);
continue;
}

break;  // 已成功生成并绑定监听socket， 退出for遍历
}

freeaddrinfo(retAddr);

if (NULL == retNext)
{
cerr << "create_and_bind error" << endl;
return 1;
}

return listenSocket;
}

int main(int argc, char **argv)
{
int ret(0);

int listenSocket(-1);
listenSocket = create_and_bind();
if (-1 == listenSocket)
{
return -1;
}

ret = setSocketNonBlock(listenSocket);
if (0 != ret)
{
return -1;
}

ret = setSocketLingerDisable(listenSocket);
if (0 != ret)
{
return -1;
}

ret = listen(listenSocket, 10);
if (0 != ret)
{
cerr << "listen error" << endl;
return -1;
}

int epollFd(-1);
epollFd = epoll_create1(0);
if (-1 == epollFd)
{
cerr << "epoll_create1 error" << endl;
return -1;
}

// 监听socket注册到epollFd中管理
struct epoll_event event;
event.data.fd = listenSocket;
event.events = EPOLLET | EPOLLIN;
ret = epoll_ctl(epollFd, EPOLL_CTL_ADD, listenSocket, &event);
if (0 != ret)
{
cerr << "epoll_ctl error" << endl;
return -1;
}

struct epoll_event retEvents[MAX_EVENTS];

bool done(false);
int retEventsCnt(0);
while (!done)
{
retEventsCnt = epoll_wait(epollFd, retEvents, MAX_EVENTS, 1000);
cout << "retEventCnt: " << retEventsCnt << endl;
for (int i = 0; i < retEventsCnt; ++i)
{
if ((retEvents[i].events & EPOLLERR) || (retEvents[i].events & EPOLLHUP) ||
!(retEvents[i].events & EPOLLIN))
{
cerr << "socketFd: " << retEvents[i].data.fd << " error" << endl;
close(retEvents[i].data.fd);
continue;
}
else if (listenSocket == retEvents[i].data.fd)
{
while (true)
{
struct sockaddr remoteSockAddr;
socklen_t len = sizeof(struct sockaddr);

int connectSocket(-1);
connectSocket = accept(listenSocket, &remoteSockAddr, &len);
if (-1 == connectSocket)
{
if (EAGAIN == errno)
{
break;
}
else
{
cerr << "accept error" << endl;
continue;
}
}

char hostStr[100];
char serviceStr[100];
ret = getnameinfo(&remoteSockAddr, sizeof(struct sockaddr), hostStr, sizeof(char[100]),
serviceStr, sizeof(char[100]), 0);
if (0 == ret)
{
printf("client info: [connectSocket: %d, host: %s, port: %s]\n", connectSocket, hostStr, serviceStr);
}

ret = setSocketNonBlock(connectSocket);
if (0 != ret)
{
return -1;
}

ret = setSocketLingerDisable(connectSocket);
if (0 != ret)
{
return -1;
}

event.data.fd = connectSocket;
event.events = EPOLLET | EPOLLIN;

ret = epoll_ctl(epollFd, EPOLL_CTL_ADD, connectSocket, &event);
if (0 != ret)
{
cerr << "epoll_ctl error" << endl;
return -1;
}
}
}
else
{
bool closeFlag(false);

while (true)
{
char recvBuf[10];

int len(-1);
len = recv(retEvents[i].data.fd, recvBuf, sizeof(char[10]), 0);
if (-1 == len)
{
if (EAGAIN == errno)    // 读完了
{
break;
}
closeFlag = true;
}
else if (0 == len)
{
closeFlag = true;
break;
}

write(1, recvBuf, len);
}

if(closeFlag)
{
cout << "close connectSocket Fd: " << retEvents[i].data.fd << endl;
close(retEvents[i].data.fd);
}
}
}
}

close(listenSocket);

return 0;
}