255 lines
6.8 KiB
C++
255 lines
6.8 KiB
C++
#include "heap_timer.hpp"
|
|
#include "timer_common.hpp"
|
|
#include <sys/epoll.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <netinet/in.h>
|
|
#include <netinet/ip.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#include <csignal>
|
|
#include <cstring>
|
|
#include <cerrno>
|
|
#include <iostream>
|
|
|
|
using std::cout;
|
|
using std::endl;
|
|
|
|
#define PORT 6666
|
|
#define MAX_EVENTS 1024
|
|
#define MAX_BUF_SIZE 1024
|
|
|
|
struct Event;
|
|
|
|
using readHandle = void(*)(Event*, ITimerContainer<Event>*);
|
|
using writeHandle = void(*)(Event*, ITimerContainer<Event>*);
|
|
|
|
// 自定义结构体，用来保存一个连接的相关数据
|
|
struct Event {
|
|
int fd;
|
|
char ip[64];
|
|
uint16_t port;
|
|
|
|
epoll_event event;
|
|
void* timer;
|
|
|
|
char buf[MAX_BUF_SIZE];
|
|
int buf_size;
|
|
|
|
readHandle read_cb;
|
|
writeHandle write_cb;
|
|
};
|
|
|
|
int epfd;
|
|
int pipefd[2];
|
|
|
|
// 超时处理的回调函数
|
|
void timeout_handle(Event* cli) {
|
|
if(cli == nullptr) return ;
|
|
cout << "Connect time out, fd:" << cli->fd << " ip;[" << cli->ip
|
|
<< ":" << cli->port << "]" << endl;
|
|
epoll_ctl(epfd, EPOLL_CTL_DEL, cli->fd, &cli->event);
|
|
|
|
close(cli->fd);
|
|
|
|
delete cli;
|
|
}
|
|
|
|
void err_exit(const char* reason) {
|
|
cout << reason << ":" << strerror(errno) << endl;
|
|
exit(1);
|
|
}
|
|
|
|
// 设置非阻塞
|
|
int setNonblocking(int fd) {
|
|
int old_option = fcntl(fd, F_GETFL);
|
|
int new_option = old_option | O_NONBLOCK;
|
|
fcntl(fd, F_SETFL, new_option);
|
|
|
|
return old_option;
|
|
}
|
|
|
|
// 设置端口复用
|
|
void setReusedAddr(int fd) {
|
|
int reuse = 1;
|
|
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
|
|
}
|
|
|
|
// 初始化 server socket
|
|
int socket_init(unsigned short port, bool reuseAddr) {
|
|
int fd = socket(AF_INET, SOCK_STREAM, 0);
|
|
if(fd < 0) err_exit("socket error");
|
|
if(reuseAddr) setReusedAddr(fd);
|
|
|
|
struct sockaddr_in addr;
|
|
bzero(&addr, 0);
|
|
addr.sin_family = AF_INET;
|
|
addr.sin_port = htons(port);
|
|
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
|
int ret = bind(fd, (struct sockaddr*)&addr, sizeof(addr));
|
|
if(ret < 0) err_exit("bind error");
|
|
|
|
setNonblocking(fd);
|
|
|
|
ret = listen(fd, 128);
|
|
if(ret < 0) err_exit("listen error");
|
|
|
|
return fd;
|
|
}
|
|
|
|
void readData(Event* ev, ITimerContainer<Event>* htc) {
|
|
ev->buf_size = read(ev->fd, ev->buf, MAX_BUF_SIZE - 1);
|
|
if(ev->buf_size == 0) {
|
|
close(ev->fd);
|
|
// 类型转换值得深思
|
|
htc->delTimer((Timer<Event>*)ev->timer);
|
|
epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ev->event);
|
|
cout << "Remote Connection has been closed, fd:" << ev->fd
|
|
<< " ip:[" << ev->ip << ":" << ev->port << "]" << endl;
|
|
delete ev;
|
|
|
|
return;
|
|
}
|
|
ev->event.events = EPOLLOUT;
|
|
epoll_ctl(epfd, EPOLL_CTL_MOD, ev->fd, &ev->event);
|
|
}
|
|
|
|
void writeData(Event* ev, ITimerContainer<Event>* htc) {
|
|
write(ev->fd, ev->buf, ev->buf_size);
|
|
|
|
ev->event.events = EPOLLIN;
|
|
epoll_ctl(epfd, EPOLL_CTL_MOD, ev->fd, &ev->event);
|
|
|
|
// 重新设置定时器
|
|
htc->resetTimer((Timer<Event>*)ev->timer, 15000);
|
|
}
|
|
|
|
// 接收连接回调函数
|
|
void acceptConn(Event* ev, ITimerContainer<Event>* htc) {
|
|
Event* cli = new Event;
|
|
struct sockaddr_in cli_addr;
|
|
socklen_t sock_len = sizeof(cli_addr);
|
|
int cfd = accept(ev->fd, (struct sockaddr*)&cli_addr, &sock_len);
|
|
if(cfd < 0) {
|
|
cout << "accept error, reason:" << strerror(errno) << endl;
|
|
return;
|
|
}
|
|
setNonblocking(cfd);
|
|
|
|
cli->fd = cfd;
|
|
cli->port = ntohs(cli_addr.sin_port);
|
|
inet_ntop(AF_INET, &cli_addr.sin_addr, cli->ip, sock_len);
|
|
cli->read_cb = readData;
|
|
cli->write_cb = writeData;
|
|
|
|
auto timer = htc->addTimer(15000); // 设置客户端超时15秒
|
|
timer->setUserData(cli);
|
|
timer->setCallBack(timeout_handle);
|
|
cli->timer = (void*)timer;
|
|
|
|
cli->event.events = EPOLLIN;
|
|
cli->event.data.ptr = (void*)cli;
|
|
epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &cli->event);
|
|
|
|
cout << "New Connection, ip:[" << cli->ip << ":" << cli->port << "]" << endl;
|
|
}
|
|
|
|
void sig_handler(int signum) {
|
|
char sig = (char)signum;
|
|
write(pipefd[1], &sig, 1);
|
|
}
|
|
|
|
int add_sig(int signum) {
|
|
struct sigaction sa;
|
|
memset(&sa, 0, sizeof(sa));
|
|
sa.sa_handler = sig_handler;
|
|
sa.sa_flags |= SA_RESTART; // 信号重置
|
|
sigfillset(&sa.sa_mask);
|
|
|
|
return sigaction(signum, &sa, nullptr);
|
|
}
|
|
|
|
int main(int argc, char* argv[]){
|
|
// 信号处理
|
|
int ret = add_sig(SIGINT);
|
|
if(ret < 0) err_exit("add sig error");
|
|
|
|
ret = socketpair(AF_UNIX, SOCK_STREAM, 0, pipefd);
|
|
if(ret < 0) err_exit("socketpair error");
|
|
|
|
int fd = socket_init(PORT, true);
|
|
Event server;
|
|
Event sig_ev;
|
|
server.fd = fd;
|
|
sig_ev.fd = pipefd[0];
|
|
|
|
epfd = epoll_create(MAX_EVENTS);
|
|
if(epfd < 0) err_exit("epoll create error");
|
|
|
|
sig_ev.event.events = EPOLLIN;
|
|
sig_ev.event.data.ptr = (void*)&server;
|
|
|
|
epoll_ctl(epfd, EPOLL_CTL_ADD, pipefd[0], &sig_ev.event);
|
|
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &server.event);
|
|
|
|
cout << "------ Create TimerContainer ------" << endl;
|
|
|
|
ITimerContainer<Event>* htc = new HeapTimerContainer<Event>;
|
|
|
|
cout << "------ Create TimerContainer over ------" << endl;
|
|
|
|
struct epoll_event events[MAX_EVENTS];
|
|
int nready = 0;
|
|
|
|
int timeout = 10000; // 设置超时值为10秒
|
|
char buf[1024] = {0};
|
|
bool running = true;
|
|
while(running) {
|
|
// 将定时器容器中定时时间最短的时长作为epoll_wait的最大等待时间
|
|
auto min_expire = htc->getMinExpire();
|
|
timeout = (min_expire == -1) ? 10000 : min_expire - getMsec();
|
|
|
|
nready = epoll_wait(epfd, events, MAX_EVENTS, timeout);
|
|
if(nready < 0) cout << "epoll wait error, reason:" << strerror(errno) << endl;
|
|
else if(nready > 0){
|
|
for(int i = 0; i < nready; i++) {
|
|
Event* ev = (Event*)events[i].data.ptr;
|
|
if(ev->fd == pipefd[0]) {
|
|
int n = read(pipefd[0], buf, sizeof(buf));
|
|
if(n < 0) {
|
|
cout << "deal read signal error:" << strerror(errno) << endl;
|
|
continue;
|
|
} else if(n > 0) {
|
|
for(int i = 0; i < n; i++) {
|
|
switch(buf[i]) {
|
|
case SIGINT:
|
|
running = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else if(ev->fd == fd) {
|
|
acceptConn(ev, htc);
|
|
} else if(ev->event.events & EPOLLIN) {
|
|
ev->read_cb(ev, htc);
|
|
} else if(ev->event.events & EPOLLOUT) {
|
|
ev->write_cb(ev, htc);
|
|
}
|
|
}
|
|
} else {
|
|
htc->tick();
|
|
}
|
|
}
|
|
|
|
close(fd);
|
|
close(pipefd[0]);
|
|
close(pipefd[1]);
|
|
delete htc;
|
|
|
|
return 0;
|
|
} |