int billing_epoll_wait()
{
int nfds;
int i;
int ret=0 ;
nfds = epoll_wait(kdpfd, events, MAX_EVENTS, EPOLL_TIMEOUT);
if(nfds == -1) {
if( errno != EINTR ) {
return -1;
}
} else if( 0 == nfds) {
return 0;
}
for (i = 0; i < nfds; i++) {
if (listen_fd == events[i].data.fd){
handle_accept(listen_fd);
}
else if (events[i].events & EPOLLIN){
read_billing_info(events[i].data.fd);
}
else if (events[i].events & (EPOLLHUP|EPOLLERR)){
disconnect_fd(events[i].data.fd);
}
}
return ret;
}
static void server_mainloop() {
int64 sock;
/* inlined livesync_init() */
memset( g_peerbuffer_start, 0, sizeof( g_peerbuffer_start ) );
g_peerbuffer_pos = g_peerbuffer_start;
memcpy( g_peerbuffer_pos, &g_tracker_id, sizeof( g_tracker_id ) );
uint32_pack_big( (char*)g_peerbuffer_pos + sizeof( g_tracker_id ), OT_SYNC_PEER);
g_peerbuffer_pos += sizeof( g_tracker_id ) + sizeof( uint32_t);
g_next_packet_time = time(NULL) + LIVESYNC_MAXDELAY;
while(1) {
/* See, if we need to connect to anyone */
if( time(NULL) > g_connection_reconn )
handle_reconnects( );
/* Wait for io events until next approx reconn check time */
io_waituntil2( 30*1000 );
/* Loop over readable sockets */
while( ( sock = io_canread( ) ) != -1 ) {
const void *cookie = io_getcookie( sock );
if( (uintptr_t)cookie == FLAG_SERVERSOCKET )
handle_accept( sock );
else
handle_read( sock );
}
/* Loop over writable sockets */
while( ( sock = io_canwrite( ) ) != -1 )
handle_write( sock );
livesync_ticker( );
}
}
int main() {
init_epoll();
create_socket();
setup_signals();
while (running) {
struct epoll_event event;
int ret = epoll_wait(epoll_fd, &event, 1, -1);
if (ret == 0)
continue;
if (ret < 0) {
if (errno == EINTR)
continue;
syslog(LOG_ERR, "epoll_wait: %s\n", strerror(errno));
exit(1);
}
if (event.data.ptr == &listen_event)
handle_accept(event.events);
else
handle_data(event.data.ptr);
}
cleanup();
}
void pipeline_acceptor::do_accept( void ){
_fd = std::move( tcp::socket( engine() ));
_acceptor.accept( _fd , [this]( const std::error_code& ec
, const tcode::io::ip::address& addr )
{
handle_accept( ec , addr );
});
}
int main(int argc,char* argv[])
{
if(argc!=2)
{
printf("Usage:./server port\n");
return 1;
}
int listen_sock=socket(AF_INET,SOCK_STREAM,0);
assert(listen_sock>=0);
sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port=htons(atoi(argv[1]));
local.sin_addr.s_addr=INADDR_ANY;
if(bind(listen_sock,(sockaddr*)&local,sizeof(local))==-1)
{
perror(strerror(errno));
return 2;
}
if(listen(listen_sock,5)==-1)
{
perror(strerror(errno));
return 3;
}
sockaddr_in client;
socklen_t len=sizeof(client);
while(1)
{
int new_sock=accept(listen_sock,(sockaddr*)&client,&len);
if(new_sock==-1)
{
continue;
}
else
{
pid_t id=fork();
assert(id>=0);
if(id>0)
{
wait(NULL);
}
else
{
pid_t tid=fork();
assert(tid>=0);
if(tid>0)
{
exit(0);
}
else
{
return handle_accept(new_sock);
}
}
}
}
return 0;
}
/**
* The listener thread main function. The listener listens for
* connections from clients.
*/
static void *listener_main(void *arg_p)
{
struct http_server_t *self_p = arg_p;
struct http_server_listener_t *listener_p;
struct http_server_connection_t *connection_p;
struct inet_addr_t addr;
thrd_set_name(self_p->listener_p->thrd.name_p);
listener_p = self_p->listener_p;
if (socket_open_tcp(&listener_p->socket) != 0) {
log_object_print(NULL,
LOG_ERROR,
FSTR("Failed to open socket."));
return (NULL);
}
if (inet_aton(listener_p->address_p, &addr.ip) != 0) {
return (NULL);
}
addr.port = listener_p->port;
if (socket_bind(&listener_p->socket, &addr) != 0) {
log_object_print(NULL,
LOG_ERROR,
FSTR("Failed to bind socket."));
return (NULL);
}
if (socket_listen(&listener_p->socket, 3) != 0) {
log_object_print(NULL,
LOG_ERROR,
FSTR("Failed to listen on socket."));
return (NULL);
}
/* Wait for clients to connect. */
while (1) {
/* Allocate a connection. */
connection_p = allocate_connection(self_p);
/* Wait for a client to connect. */
socket_accept(&listener_p->socket,
&connection_p->socket,
&addr);
handle_accept(self_p, connection_p);
}
return (NULL);
}
static void handle_fd_set(isrv_state_t *state, fd_set *fds, int (*h)(int, void **))
{
enum { LONG_CNT = sizeof(fd_set) / sizeof(long) };
int fds_pos;
int fd, peer;
/* need to know value at _the beginning_ of this routine */
int fd_cnt = FD_COUNT;
if (LONG_CNT * sizeof(long) != sizeof(fd_set))
BUG_sizeof_fd_set_is_strange();
fds_pos = 0;
while (1) {
/* Find next nonzero bit */
while (fds_pos < LONG_CNT) {
if (((long*)fds)[fds_pos] == 0) {
fds_pos++;
continue;
}
/* Found non-zero word */
fd = fds_pos * sizeof(long)*8; /* word# -> bit# */
while (1) {
if (FD_ISSET(fd, fds)) {
FD_CLR(fd, fds);
goto found_fd;
}
fd++;
}
}
break; /* all words are zero */
found_fd:
if (fd >= fd_cnt) { /* paranoia */
DPRINTF("handle_fd_set: fd > fd_cnt?? (%d > %d)",
fd, fd_cnt);
break;
}
DPRINTF("handle_fd_set: fd %d is active", fd);
peer = FD2PEER[fd];
if (peer < 0)
continue; /* peer is already gone */
if (peer == 0) {
handle_accept(state, fd);
continue;
}
DPRINTF("h(fd:%d)", fd);
if (h(fd, &PARAM_TBL[peer])) {
/* this peer is gone */
remove_peer(state, peer);
} else if (TIMEOUT) {
TIMEO_TBL[peer] = monotonic_sec();
}
}
}
void handle_message(struct msg incoming_msg, struct state_info info) {
char diag[200];
sprintf(diag,"receive %s from %d [phase=%s, timestamp=%d, lift_number=%s]",
stringify(incoming_msg.tag), incoming_msg.sender_tid, stringify(info.phase),
incoming_msg.timestamp, stringify(incoming_msg.tag == MSG_ACCEPT ? -1 : incoming_msg.lift_number));
diag_msg(info.mstrtid, info.mytid, diag);
switch (incoming_msg.tag) {
case MSG_REQUEST: handle_request(incoming_msg, info); break;
case MSG_ACCEPT: handle_accept (incoming_msg, info); break;
case MSG_RELEASE: handle_release(incoming_msg, info); break;
}
}
void handle_events(int epollfd, struct epoll_event *events, int num, int listenfd, char* buf){
int i, fd;
for(i = 0; i < num; ++i){
fd = events[i].data.fd;
if((fd == listenfd) && (events[i].events & EPOLLIN)){
handle_accept(epollfd, listenfd);
}else if(events[i].events & EPOLLIN){
do_read(epollfd, fd, buf);
}else if(events[i].events & EPOLLOUT){
do_write(epollfd, fd, buf);
}
}
}
static void
handle_events(int epollfd,struct epoll_event *events,int num,int listenfd,char *buf)
{
int i;
int fd;
//进行选好遍历
for (i = 0;i < num;i++)
{
fd = events[i].data.fd;
//根据描述符的类型和事件类型进行处理
if ((fd == listenfd) &&(events[i].events & EPOLLIN))
handle_accept(epollfd,listenfd);
else if (events[i].events & EPOLLIN)
do_read(epollfd,fd,buf);
else if (events[i].events & EPOLLOUT)
do_write(epollfd,fd,buf);
}
}
static void server_mainloop( ) {
static time_t ot_last_clean_time;
time_t next_timeout_check = g_now + OT_CLIENT_TIMEOUT_CHECKINTERVAL;
struct iovec *iovector;
int iovec_entries;
for( ; ; ) {
int64 i;
io_wait();
while( ( i = io_canread( ) ) != -1 ) {
const void *cookie = io_getcookie( i );
if( cookie == FLAG_TCP )
handle_accept( i );
else if( cookie == FLAG_UDP )
handle_udp4( i );
else
handle_read( i );
}
while( ( i = mutex_workqueue_popresult( &iovec_entries, &iovector ) ) != -1 )
http_sendiovecdata( i, iovec_entries, iovector );
while( ( i = io_canwrite( ) ) != -1 )
handle_write( i );
if( g_now > next_timeout_check ) {
while( ( i = io_timeouted() ) != -1 )
handle_dead( i );
next_timeout_check = g_now + OT_CLIENT_TIMEOUT_CHECKINTERVAL;
}
/* See if we need to move our pools */
if( NOW != ot_last_clean_time ) {
ot_last_clean_time = NOW;
clean_all_torrents();
}
/* Enforce setting the clock */
signal_handler( SIGALRM );
}
}
void handle_poll(int listenfd)
{
int connfd, sockfd;
struct sockaddr_in cliaddr;
socklen_t cliaddrlen;
struct pollfd clientfds[OPEN_MAX];
int nready;
//添加监听描述符
clientfds[0].fd = listenfd;
clientfds[0].events = POLLIN;
//初始化客户连接描述符
//int i, conn_num = 1;
int i, imax = 0;
for (i = 1; i < OPEN_MAX; i++)
{
clientfds[i].fd = -1;
}
//循环处理
while(1)
{
//获取可用描述符的个数
printf("wztest ==================\n");
nready = poll(clientfds, imax + 1 , -1);
if (nready == -1)
{
perror("poll error:");
exit(1);
}
if (clientfds[0].revents & POLLIN) {
handle_accept(listenfd, clientfds, &imax);
}
//if (--nready > 0){
handle_connect(clientfds, imax);
//}
}
}
static void handle_events( int _epollfd, struct epoll_event* _events, int _num, int _listenfd, char* _buf )
{
int fd = 0;
for( int i = 0; i < _num; ++i )
{
fd = _events[i].data.fd;
//根据描述符的类型和事件类型进行处理
if( (fd == _listenfd) && (_events[i].events & EPOLLIN) )
{
handle_accept( _epollfd, _listenfd );
}
else if( _events[i].events & EPOLLIN )
{
do_read( _epollfd, fd, _buf );
}
else if( _events[i].events & EPOLLOUT )
{
do_write( _epollfd, fd, _buf );
}
}
}
int
main(int argc, char *argv[])
{
int err;
int nfds;
int socketfd;
db_t db;
db_option_t option;
fd_set readfds;
fd_set writefds;
char *dbfilename;
char *idxfilename;
struct addrinfo hints, *ai, *p;
if (argc == 2) {
dbfilename = argv[1];
idxfilename = NULL;
} else if (argc != 3) {
dbfilename = argv[1];
idxfilename = argv[2];
} else {
fprintf(stderr, "usage: %s dbfile [indexfile]\n", argv[0]);
return 0;
}
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
if ((err = getaddrinfo(NULL, PORT, &hints, &ai)) != 0) {
fprintf(stderr, "db-server: getaddrinfo: %s\n", gai_strerror(err));
exit(1);
}
for (p = ai; p != NULL; p = p->ai_next) {
int optval = 1;
socketfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
if (socketfd == -1) {
fprintf(stderr, "db-server: socket: %s\n", gai_strerror(err));
continue;
}
if (fcntl(socketfd, F_SETFL, O_NONBLOCK) == -1) {
fprintf(stderr, "db-server: fcntl NONBLOCK: %s\n", strerror(errno));
continue;
}
if (setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) == -1) {
fprintf(stderr, "db-server: setsockopt REUSEADDR: %s\n", strerror(errno));
continue;
}
if (bind(socketfd, p->ai_addr, p->ai_addrlen) < 0) {
fprintf(stderr, "db-server: bind: %s\n", strerror(errno));
close(socketfd);
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "db-server: failed to bind: %s\n", PORT);
exit(1);
}
freeaddrinfo(ai);
option.table = 256;
option.bucket = 256;
option.rdonly = 0;
if (db_open(&db, dbfilename, idxfilename, &option) != DB_OK) {
fprintf(stderr, "db-server: open db %s failed\n", dbfilename);
exit(0);
}
if (listen(socketfd, 32) == -1) {
fprintf(stderr, "db-server: listen: %s\n", strerror(errno));
exit(1);
}
FD_ZERO(&readfds);
FD_ZERO(&writefds);
nfds = socketfd;
FD_SET(socketfd, &readfds);
inbuf = malloc(INBUF_LEN);
outbuf = malloc(OUTBUF_LEN);
valbuf = malloc(VALBUF_LEN);
for (;;) {
int n;
int fd;
fd_set readfds_;
fd_set writefds_;
FD_ZERO(&readfds_);
FD_ZERO(&writefds_);
#ifdef LINUX
memcpy(&readfds_, &readfds, sizeof(readfds));
memcpy(&writefds_, &writefds, sizeof(writefds));
#else
FD_COPY(&readfds, &readfds_);
FD_COPY(&writefds, &writefds_);
#endif
if ((n = select(nfds + 1, &readfds_, &writefds_, NULL, NULL)) == -1) {
fprintf(stderr, "db-server: select: %s\n", strerror(errno));
exit(1);
}
for (fd = 0; fd <= nfds && n > 0; fd++) {
if (FD_ISSET(fd, &writefds_)) {
n--;
handle_write(fd, &readfds, &writefds);
}
if (FD_ISSET(fd, &readfds_)) {
n--;
if (fd == socketfd) {
int acceptfd;
acceptfd = handle_accept(fd, &readfds, &writefds);
if (acceptfd > nfds) {
nfds = acceptfd;
}
} else {
err = handle_read(fd, &db, &readfds, &writefds);
if (err == -1 && fd >= nfds) {
nfds = fd;
while (FD_ISSET(nfds, &readfds) == 0 &&
FD_ISSET(nfds, &writefds) == 0)
{
nfds--;
}
}
}
}
}
}
free(inbuf);
free(outbuf);
free(valbuf);
return 0;
}
bool TcpServer::_StartUpLin()
{
#ifndef WIN32
int loop_times = 0;
const int timer_check_point = 10; //达到指定循环次数即开始timer检查
while(m_bRun)
{
int res = epoll_wait(m_epoll_fd, m_epev_arr, EVENT_TOTAL_COUNT, 100);
if ( res < 0) {
//及时退出，否则会导致 CPU 100%
if (EINTR == errno)
continue;
log_debug("epoll_wait return false, errno = %d\n", errno);
break;
}
else if (0 == res) { //timeout
loop_times = 0;
run_timer();
}
else {
//间隔一定次数即开始检查定时器的超时事件
if (++loop_times >= timer_check_point) {
loop_times = 0;
//驱动定时器处理
run_timer();
}
}
for(int i=0; i<res; i++)
{
if(m_epev_arr[i].data.fd == m_listen_fd)
{
handle_accept();
continue;
}
int fd = (uint32_t)m_epev_arr[i].data.u64; /* mask out the lower 32 bits */
uint32 index = (uint32_t)(m_epev_arr[i].data.u64 >> 32);
TcpHandler* s = fds[fd];
if( s == 0 || s->get_fd_index() != index )
{
continue; // epoll returned invalid fd
}
if( m_epev_arr[i].events & ( EPOLLHUP | EPOLLERR ))
{
handle_close(s);
continue;
}
else if(m_epev_arr[i].events & EPOLLIN )
{
if(s->handle_read() == -1)
{
handle_close(s);
continue;
}
if( s->Writable() )
WantWrite(s);
}
else if(m_epev_arr[i].events&EPOLLOUT)
{
if(s->handle_output() == -1)
{
handle_close(s);
continue;
}
if(!s->Writable())
WantRead(s);
}
}
}
#endif
return true;
}
bool TcpServer::_StartUpWin()
{
#ifdef WIN32
struct timeval tv = {1, 000000};
while(m_bRun)
{
m_tmp_rset = m_rset;
m_tmp_wset = m_wset;
int ready = select(m_maxfd+1, &m_tmp_rset, &m_tmp_wset, NULL, &tv);
if(ready == -1)
{
int err = WSAGetLastError();
if (err != EINTR)
{
return false;
}
}
else if (ready == 0)
{
run_timer();
continue;
}
else
{
run_timer();
if (FD_ISSET(m_listen_fd, &m_tmp_rset))
{
handle_accept();
--ready;
}
for (int i=0; ready > 0 && i< m_maxfd; i++)
{
TcpHandler* p_socket = fds[i];
if(p_socket == NULL)
{
continue;
}
if(FD_ISSET(p_socket->GetFd(), &m_tmp_rset))
{
--ready;
if (p_socket->handle_read() == -1)
{
handle_close(p_socket);
continue;
}
}
if(FD_ISSET(p_socket->GetFd(), &m_tmp_wset))
{
--ready;
if (p_socket->handle_output() == -1)
{
handle_close(p_socket);
}
}
}
}
}
#endif // WIN32
return true;
}
int main(int argc, const char* argv[])
{
struct sockaddr_in sAddr;
struct epoll_event ev;
struct epoll_event evlist[MAX_EVENTS];
int ready, i;
int listensock = 0;
int result=0, val = 0;
//init epoll
if( init_epoll() ){
exit(-1);
}
printf("epoll instance created success! \n");
//create socket
if ( -1 == (listensock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))) {
perror("create socket error!");
exit(1);
}
val = 1;
result = setsockopt(listensock, SOL_SOCKET, SO_REUSEADDR, &val,sizeof(val));
if( result < 0 ){
perror("set socket option error!");
exit(1);
}
sAddr.sin_family = AF_INET;
sAddr.sin_port = htons(g_server_port);
sAddr.sin_addr.s_addr = INADDR_ANY;
//now bind the address and port
result = bind(listensock, (struct sockaddr*)&sAddr, sizeof(sAddr));
if ( result < 0 ) {
perror("bind error!");
exit(1);
}
//print server ready info
printf("Server get ready at port : %d \n", g_server_port);
result = listen(listensock, 5);
if( result < 0 ) {
perror("listen error!");
exit(1);
}
setnonblocking(listensock); //set nonblocking
ev.events = EPOLLIN|EPOLLET; //edge-trigged
ev.data.fd = listensock;
if( epoll_ctl(epfd, EPOLL_CTL_ADD, listensock, &ev) == -1 ){
perror("epoll_ctl add error!");
exit(-1);
}
//now we will epoll_wait the event
//
while(1) {
//Fetch up to MAX_EVENTS items from the ready list
//printf("About to epoll_wait() \n");
ready = epoll_wait(epfd, evlist, MAX_EVENTS, -1);
if( ready == -1 ){
if( errno == EINTR ){
printf("Get an intr signal!\n");
continue;
} else {
perror("epoll_wait error!");
exit(-1);
}
}
for(i=0;i<ready;i++){
/* printf("fd=%d, events: %s%s%s%s \n",evlist[i].data.fd,
(evlist[i].events & EPOLLIN)? "EPOLLIN ":"",
(evlist[i].events & EPOLLOUT)? "EPOLLOUT ":"",
(evlist[i].events & EPOLLHUP)? "EPOLLHUP ":"",
(evlist[i].events & EPOLLERR)? "EPOLLERR ":"");
*/
//deal with events
if( evlist[i].events & EPOLLIN ){
if( evlist[i].data.fd == listensock ){
handle_accept(evlist[i].data.fd);
} else {
handle_read(evlist[i].data.fd);
}
}
else if( evlist[i].events & EPOLLOUT){
handle_write(evlist[i].data.fd);
}
else if( evlist[i].events &(EPOLLHUP|EPOLLERR)){
printf("Client on descriptor #%d disconnetcted. \n", evlist[i].data.fd);
if( close( evlist[i].data.fd ) == -1 ){
perror("close fd error!");
exit(-1);
}
}
}//end of for ready
}//end of while
return 0;
}
NET_API int
net_wait(struct net_service* service, int timeout)
{
int ret;
int err;
struct iocp_data* ov_data;
PULONG_PTR data;
DWORD bytes;
int cnt;
#if _WIN32_WINNT >= 0x0600
ULONG ulCount;
ULONG ulNR;
ULONG i;
OVERLAPPED_ENTRY entries[32];
cnt = 0;
ulCount = sizeof(entries) / sizeof(OVERLAPPED_ENTRY);
ulNR = 0;
ov_data = 0;
data = 0;
bytes = 0;
err = 0;
while(1)
{
ret = GetQueuedCompletionStatusEx(service->net_service_fd, entries, ulCount, &ulNR, timeout, 0);
err = net_get_error();
if (err == WAIT_TIMEOUT)
{
err = 0;
}
if (!ret)
{
if (err)
{
return -err;
}
return cnt;
}
for (i = 0; i < ulNR; ++i)
{
ov_data = (struct iocp_data*)entries[i].lpOverlapped;
bytes = entries[i].dwNumberOfBytesTransferred;
if (ov_data)
{
switch(ov_data->op_type)
{
case OP_NET_ACCEPT:
handle_accept(service, ret, err, (struct accept_session*)ov_data);
break;
case OP_NET_READ:
handle_read(service, ret, err, (struct read_session*)ov_data, bytes);
break;
case OP_NET_WRITE:
handle_write(service, ret, err, (struct write_session*)ov_data, bytes);
break;
case OP_NET_CONNECT:
handle_connect(service, ret, err, (struct connect_session *)ov_data, bytes);
break;
}
}
}
cnt += (int)ulNR;
}
return cnt;
#else
cnt = 0;
while(1)
{
ret = GetQueuedCompletionStatus(service->net_service_fd, &bytes, (PULONG_PTR) &data, (LPOVERLAPPED*)&ov_data, timeout);
err = 0;
if (!ret)
{
err = net_get_error();
}
if (err == WAIT_TIMEOUT)
{
err = 0;
}
if(!ov_data)
{
if(err)
{
return -err;
}
return cnt;
}
else
{
switch(ov_data->op_type)
{
case OP_NET_ACCEPT:
handle_accept(service, ret, err, (struct accept_session*)ov_data);
break;
case OP_NET_READ:
handle_read(service, ret, err, (struct read_session*)ov_data, bytes);
break;
case OP_NET_WRITE:
handle_write(service, ret, err, (struct write_session*)ov_data, bytes);
break;
case OP_NET_CONNECT:
handle_connect(service, ret, err, (struct connect_session *)ov_data, bytes);
break;
}
}
cnt += 1;
}
return cnt;
#endif
}
