Linux 下使用epoll实现转发服务器的小DEMO

#ifndef _BTERR_H_
#define _BTERR_H_
#include <stdexcept>
#include <string>
using namespace std;
class btsock_err : public exception {
private:
string m_errstr;
public:
btsock_err (const string& errstr);
~btsock_err (void) throw();
const char* what (void) const throw ();
};
#endif //_BTERR_H_

#include "bterr.h"
btsock_err::btsock_err (const string& errstr) :
m_errstr (errstr) {}
btsock_err::~btsock_err (void) throw() {}

const char* btsock_err::what (void) const throw()
{
return m_errstr.c_str();
}

#ifndef _BTSOCKET_H_
#define _BTSOCKET_H_
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
using namespace std;
enum enum_btstatus {e_start = 1, e_init, e_bind, e_listen, e_accept, e_connect, e_end};
class Btsocket {
private:
string m_host;
unsigned short m_port;
int m_family;
int m_socktype;
int m_protocol;
int m_fd;
enum_btstatus m_status;

static const int MAX_CLIENT;

void initSocket (void);

public:
Btsocket (const string& host, unsigned short port, int max = 50,
int family = AF_INET, int socktype = SOCK_STREAM,
int protocol = 0);
Btsocket (const char* host, unsigned short port, int max = 50,
int family = AF_INET, int socktype = SOCK_STREAM,
int protocol = 0);
Btsocket (int fd);
Btsocket (void);
~Btsocket (void);

Btsocket& makeSocketNonBlock(void);

const int getFd(void) const;

Btsocket& bind (void);

void listen (void);

Btsocket accept(void);

void connect (void);

ssize_t send (const void* data, size_t size, int reset = 5) const;

ssize_t recv (void* data, size_t size) const;

void close (void) const;
};
#endif // _BTSOCKET_H_

#include "btsocket.h"
#include "bterr.h"
#include <iostream>
void Btsocket::initSocket (void)
{
m_fd = socket (m_family, m_socktype, m_protocol);
if (0 >  m_fd)
throw btsock_err ("创建socket失败");
m_status = e_init;
}

Btsocket& Btsocket::makeSocketNonBlock(void)
{
int flags;
flags = fcntl (m_fd, F_GETFL, 0);
if (-1 == flags)
throw ("set non blocking: 获取文件标志失败");
flags |= O_NONBLOCK;
if (-1 == fcntl(m_fd, F_SETFL, flags))
throw ("set non blocking: 设置文件标志失败");

return *this;
}

Btsocket::Btsocket(const string& host, unsigned short port,
int max, int family, int socktype, int protocol) :
m_host (host), m_port (port), m_family (family),
m_socktype (socktype), m_protocol (protocol), m_status (e_start)
{
initSocket();
}

Btsocket::Btsocket (const char* host, unsigned short port,
int max, int family, int socktype, int protocol) :
m_host (string(host)), m_port (port),
m_family (family), m_socktype (socktype),
m_protocol (protocol), m_status (e_start)
{
initSocket();
}

Btsocket::Btsocket (int fd) : m_fd (fd), m_status (e_end)
{}

Btsocket::Btsocket (void) : m_fd (0), m_status (e_start)
{}
Btsocket::~Btsocket (void)
{
}

const int Btsocket::getFd(void) const
{
return m_fd;
}

Btsocket& Btsocket::bind (void)
{
if (m_status != e_init)
throw btsock_err ("当前状态不可绑定");
sockaddr_in serverAddr;
serverAddr.sin_family = m_family;
serverAddr.sin_addr.s_addr = inet_addr(m_host.c_str());
serverAddr.sin_port = htons (m_port);

if (0 > ::bind (m_fd, reinterpret_cast<struct sockaddr*>(&serverAddr), sizeof(serverAddr)))
throw btsock_err ("绑定失败");
m_status = e_bind;
return *this;
}

void Btsocket::listen(void)
{
if (m_status != e_bind)
throw btsock_err ("当前状态不可监听");
if (0 > ::listen (m_fd, MAX_CLIENT))
throw btsock_err ("监听失败");
m_status = e_listen;
}

Btsocket Btsocket::accept(void)
{
if (m_status != e_listen)
throw btsock_err ("当前状态不可接受连接");
sockaddr in_addr;
socklen_t  in_len;
int cfd;
in_len = sizeof (in_addr);
cfd = ::accept (m_fd, &in_addr, &in_len);
if (0 > cfd)
throw btsock_err ("accept失败");
//m_status = e_accept;
Btsocket client(cfd);
client.makeSocketNonBlock();
return client; // 构造客户端socket

}

void Btsocket::connect (void)
{
if (m_status != e_init)
throw btsock_err ("当前状态不可连接服务器");
sockaddr_in serverAddr;
serverAddr.sin_family = m_family;
serverAddr.sin_addr.s_addr = inet_addr(m_host.c_str());
serverAddr.sin_port = htons (m_port);
if (0 > ::connect (m_fd, (struct sockaddr*)&serverAddr, sizeof (sockaddr)))
throw btsock_err ("连接失败");
m_status = e_connect;
}

ssize_t Btsocket::send(const void* data, size_t size, int reset) const
{
if (m_status != e_connect && m_status != e_end)
throw btsock_err("当前状态不可发送数据");
ssize_t sendSize = 0, send = 0;
char* _data = static_cast<char*>(const_cast<void*>(data));
do {
sendSize = ::send (m_fd, _data, size, 0);
_data = _data + sendSize;
size = size - sendSize;
send += sendSize;
--reset; //重试次数
} while (sendSize < size || reset > 0);
return send;
}

ssize_t Btsocket::recv(void* data, size_t size) const
{
//std::cout << "接收时状态: " << m_status << std::endl;
if (m_status != e_connect && m_status != e_end)
throw btsock_err("当前状态不可接收数据");
return ::recv(m_fd, data, size, MSG_DONTWAIT);
}

void Btsocket::close(void) const
{
::close(m_fd);
}
const int Btsocket::MAX_CLIENT = 50;

#include <iostream>
#include "btsocket.h"
#include "bterr.h"
#include <sys/epoll.h>
#include <map>
#define MAXEVENTS 64
using namespace std;

int main(int argc, char* argv[])
{
try {
epoll_event event, *events;
int efd, s, clientNum = 0;
//Btsocket client[1024];
map<int, Btsocket> clientMap;
Btsocket server("127.0.0.1", 7777);
server.makeSocketNonBlock().bind().listen();
efd = epoll_create1(0);
if (-1 == efd)
throw btsock_err("创建epoll失败");
event.data.fd = server.getFd();
event.events = EPOLLIN | EPOLLET;
s = epoll_ctl (efd, EPOLL_CTL_ADD, server.getFd(), &event);
if (-1 == s)
throw btsock_err ("添加服务到epoll失败");
events = new epoll_event;
for (;;)
{
int n, i, j;
n = epoll_wait (efd, events, MAXEVENTS, -1);
for (i = 0; i < n; ++i)
{
if ((events[i].events & EPOLLERR) ||
(events[i].events & EPOLLHUP) ||
(!(events[i].events & EPOLLIN)))
{
if (clientMap.find(events[i].data.fd) != clientMap.end())
clientMap.erase(events[i].data.fd);
close (events[i].data.fd);
epoll_ctl(efd, EPOLL_CTL_DEL, events[i].data.fd, &(events[i]));
continue;
}
else if (server.getFd() == events[i].data.fd)
{
Btsocket c = server.accept();
clientMap.insert(pair<int, Btsocket>(c.getFd(), c));
event.data.fd = c.getFd(); //需要把client 保存起来, 以执行析构
event.events = EPOLLIN | EPOLLET;

s = epoll_ctl(efd, EPOLL_CTL_ADD, c.getFd(), &event);
if (-1 == s)
{
cout << "添加客户端到epoll失败" << endl;
continue;
}
}
else
{
ssize_t count = 0;
char buf[1024] = {0};
count = clientMap[events[i].data.fd].recv((void*) buf, 1024);
for (map<int, Btsocket>::iterator it = clientMap.begin(); it != clientMap.end(); ++it)
it->second.send((void*)buf, count);
}
}
}
server.close();
for (map<int, Btsocket>::iterator  it = clientMap.begin(); it != clientMap.end(); ++it)
it->second.close();
} catch (exception& ex) {
cout << ex.what() << endl;
return -1;
}
return 0;
}

#include <iostream>
#include "btsocket.h"
#include "bterr.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

int main(int argc, char* argv[])
{
try {
Btsocket server("127.0.0.1", 7777);
server.connect();
fd_set fset;
struct timeval tval = {1, 0};
FILE* fd = stdin;
char buf[1024] = "";
FD_ZERO(&fset);
for (;;)
{
FD_SET (server.getFd(), &fset);
FD_SET (fileno(fd), &fset);
select (50, &fset, NULL, NULL, &tval);
if (FD_ISSET(server.getFd(), &fset))
{
server.recv((void*)buf, 1024);
cout << "接收到:" << buf << endl;
}

if (FD_ISSET(fileno(fd), &fset))
{
fgets(buf, 1024, stdin);
ssize_t count = server.send((void*)buf, strlen(buf));
cout << "已发送:" << count << " Bytes" << endl;
}
}
server.close();
} catch (exception& ex) {
cout << ex.what() << endl;
return -1;
}

return 0;
}