回射客户端服务器epoll( echo client && server improved by epoll function )

select :

1.The file descriptors that one process open is limited.

2.FD_SETSIZE

poll : The file descriptors that one process open is limited.

ulimit -n number

The file descriptors that the system run is limited with the memory.

the common points :

The kernel needs to traverse all of the file descriptors until it found the file descriptor with event occurrence. But when the number of file descriptor grows significantly , the efficiency of select function and poll function will decline heavily.So we
use another strategy , that's epoll.

Client :

/************************************************************************
>file name : echocli.c
> Author: ma6174
> Mail: ma6174@163.com
> Created Time: Thu 29 Oct 16:38:57 2015
************************************************************************/

#include <stdio.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#define ERR_EXIT(m) \
do \
{\
perror(m) ;\
exit(EXIT_FAILURE) ;\
}while(0)

//ssize_t signed integer   size_t unsigned integer
ssize_t readn ( int fd , void *buf , size_t count )    // encapsulate readn as the function of read
{
size_t nleft = count ;
ssize_t nread ;
char *bufp ;
bufp = ( char *) buf ;
//	printf ("nleft = %d\n" , nleft ) ;
while ( nleft > 0 )
{
//		printf ("nleft = %d\n" , nleft ) ;
nread = read ( fd , bufp , nleft ) ;
//                printf ("nread = %d\n" , nread ) ;
if( nread  < 0 )
{
if ( errno == EINTR )   // interrupted by signal , we don't think this occasion is not right
{
continue ;
}
return -1 ;
}
else if ( 0 == nread )    //peer closed
{
return count - nleft ;
//break ;
}
//		printf ("nreaad = %d\n" , nread ) ;
bufp += nread ;
nleft -= nread ;
}
return  count ;
}

ssize_t writen ( int fd , const void *buf ,size_t count )
{
size_t nleft = count ;
ssize_t nwritten ;
char *bufp ;
bufp = ( char * ) buf ;
while ( nleft > 0 )
{
if ( ( nwritten = write ( fd , bufp , nleft ) ) < 0 )
{
if ( errno == EINTR )  // just like the occasion in writen
{
continue ;
}
return -1 ;
}
else if ( 0 == nwritten  ) // if 0 == nread , like nothing happened to write ...
{
continue ;
}
bufp += nwritten ;
nleft -= nwritten ;
}
return count ;
}

ssize_t recv_peek ( int sockfd , void *buf , size_t len )
{
while ( 1 )
{
int ret = recv ( sockfd , buf , len , MSG_PEEK ) ;
//only let buf read the data from sockfd but not remove the data from that sockfd(socket)
//in comparison with read function it receive the data and remove the data in the socket
if ( -1 == ret && EINTR == errno )
{
continue ;			//interrupted by signal
}
return ret ;
}
}

ssize_t readline ( int sockfd , void *buf  , size_t maxline )
{
int ret ;
int nread ;
char *bufp ;
bufp = (char*) buf ;
int nleft ;
nleft = maxline ;
while (1 )
{
ret = recv_peek ( sockfd, bufp , nleft ) ;
if ( ret < 0 )    //failure
{
return ret ;
}
else if ( 0 == ret )		// peer closed
{
return ret ;
}
nread = ret ;
int i ;
for ( i = 0 ; i < nread ; i ++ )
{
if ( '\n' ==  bufp[i])
{
ret = readn (sockfd,bufp , i+1) ;
if ( ret != i + 1 )
{
exit(EXIT_FAILURE) ;
}
return ret ;
}
}
if ( nread > nleft )   // the data that we read(nread) can't be more than the real data in the socket
{
exit ( EXIT_FAILURE ) ;
}
nleft -= nread ;
ret = readn ( sockfd , bufp , nread ) ;  // read n characters from the socket ( don't contain '\n')
if ( ret != nread )
{
exit(EXIT_FAILURE ) ;
}
bufp += nread ;
}
return -1 ;
}

int
main ()
{
int sock ;
if (( sock= socket ( PF_INET , SOCK_STREAM , IPPROTO_TCP )) < 0 )
{
ERR_EXIT("socket") ;
}
struct sockaddr_in servaddr ;
memset ( & servaddr , 0 , sizeof(servaddr) ) ;
servaddr.sin_family = AF_INET ;
servaddr.sin_port = htons (5188) ;
//servaddr.sin_addr.s_addr  = htonl(INADDR_ANY) ;
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1") ;
//inet_aton("127.0.0.1" , &servaddr.sin_addr) ;
if ( connect ( sock , ( struct sockaddr * )& servaddr, sizeof(servaddr )) < 0 )
{
ERR_EXIT("connet") ;
}
printf ("connected already\n") ;
struct sockaddr_in localaddr ;
socklen_t addrlen = sizeof(localaddr) ;
if ( getsockname ( sock , ( struct sockaddr *) &localaddr , &addrlen ) < 0 )
{
ERR_EXIT ("getsockname") ;
}
printf ("local_ip = %s local_port = %d\n" , inet_ntoa (localaddr.sin_addr ) , ntohs(localaddr.sin_port) ) ;
struct sockaddr_in peeraddr ;
socklen_t peerlen = sizeof(peeraddr) ;
if ( getpeername ( sock , ( struct sockaddr * ) &peeraddr , &peerlen ) < 0 )
{
ERR_EXIT ("getpeername") ;
}
printf ("peer_ip = %s peer_port = %d\n" , inet_ntoa (peeraddr.sin_addr ) , ntohs(peeraddr.sin_port) ) ;
char sendbuf[1024]={0} ;
char recvbuf[1024]={0} ;
memset ( sendbuf , 0 , sizeof(sendbuf) ) ;
memset ( recvbuf , 0 , sizeof(recvbuf) ) ;
int n ;
while( fgets ( sendbuf , sizeof(sendbuf) , stdin ) != NULL )
{
//fgets get the data with '\n' in default
writen ( sock , sendbuf ,strlen(sendbuf) ) ;     // the former 4 bytes and  the real data(n)
int ret = readline ( sock , recvbuf , sizeof(recvbuf) ) ;
if ( -1 == ret )
{
ERR_EXIT ("readline") ;
}
else if ( 0 == ret  )            //may interrupted by signal
{
printf ("clien________ close\n") ;
break ;
}
fputs ( recvbuf , stdout ) ;
memset ( sendbuf , 0 , sizeof(sendbuf) ) ;
memset ( recvbuf , 0 , sizeof(recvbuf) ) ;
}
close ( sock ) ;
return 0 ;
}

Server(write with c++ , cpp file ):

#include <stdio.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/epoll.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <vector>
#include <algorithm>
#include <signal.h>

typedef std::vector<struct epoll_event> EventList ;

#define ERR_EXIT(m) \
do \
{ \
perror(m) ; \
exit(EXIT_FAILURE) ; \
}while(0)

void activate_nonblock ( int fd )
{
int ret ;
int flags = fcntl (fd , F_GETFL ) ;
if ( -1 == flags )
{
ERR_EXIT("fcntl\n") ;
}
flags |= O_NONBLOCK ;
ret = fcntl(fd , F_SETFL , flags ) ;
if ( -1 == ret )
{
ERR_EXIT ("fcntl") ;
}
}

ssize_t readn ( int fd , void *buf , size_t count )
{
size_t nleft ;
nleft = count ;
ssize_t nread ;
char *bufp = (char*) buf ;
while( nleft > 0 )
{
if ( ( nread = read ( fd , bufp , nleft ) ) < 0 )
{
if ( EINTR == errno )
{
continue ;
}
return -1 ;
}
else if ( 0 == nread )
{
return count - nleft ;
}
bufp += nread ;
nleft -= nread ;
}
return count ;
}

ssize_t writen ( int fd , const void *buf , size_t count )
{
size_t nleft = count ;
ssize_t nwritten ;
char *bufp = (char*) buf ;
while( nleft > 0 )
{
if ( ( nwritten= write ( fd , bufp , nleft ) ) < 0 )
{
if ( EINTR == errno )
{
continue ;
}
return -1 ;
}
else if ( 0 == nwritten )
{
continue ;
}
bufp += nwritten ;
nleft -= nwritten ;
}
return count ;
}

ssize_t recv_peek ( int sockfd , void *buf , size_t len )
{
while(1)
{
int ret = recv ( sockfd , buf , len , MSG_PEEK ) ;
if ( -1 == ret && EINTR == errno )
{
continue ;
}
return ret ;
}
}

ssize_t readline ( int sockfd , void *buf , size_t maxline )
{
int ret ;
int nread ;
char *bufp = ( char * ) buf ;
int nleft ;
nleft = maxline ;
while ( 1 )
{
ret = recv_peek ( sockfd , bufp , nleft ) ;
if ( ret < 0 )
{
return ret ;
}
else if ( 0 == ret )
{
return ret ;
}
nread = ret ;
int i ;
for ( i = 0 ; i < nread ; i ++ )
{
if ( '\n' == bufp[i] )
{
ret = readn ( sockfd , bufp , i + 1 ) ;
if ( ret != i + 1 )
{
exit ( EXIT_FAILURE ) ;
}
return ret ;
}
}
if ( nread > nleft )
{
exit(EXIT_FAILURE ) ;
}
nleft -= nread ;
bufp += nread ;
}
return -1 ;
}

void handle_sigchld ( int sig )
{
while( waitpid ( -1 , NULL , WNOHANG ) > 0 )
;
}

void handle_sigpipe ( int sig )
{
printf ("recv a sig = %d\n" , sig ) ;
}

int
main (void)
{
int count ;
count = 0 ;
signal ( SIGPIPE , handle_sigpipe ) ;
signal ( SIGCHLD , handle_sigchld ) ;
int listenfd ;
if ( ( listenfd = socket ( PF_INET , SOCK_STREAM , IPPROTO_TCP ) ) < 0 )
{
ERR_EXIT("socket") ;
}
struct sockaddr_in servaddr ;
memset ( &servaddr , 0 , sizeof(servaddr)) ;
servaddr.sin_family = AF_INET ;
servaddr.sin_port = htons(5188) ;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY) ;

int on = 1 ;
if ( setsockopt ( listenfd , SOL_SOCKET , SO_REUSEADDR , &on , sizeof(on) ) < 0 )
{
ERR_EXIT("setsockopt") ;
}
if ( bind ( listenfd , ( struct sockaddr*) &servaddr , sizeof(servaddr) ) < 0 )
{
ERR_EXIT("bind") ;
}
if ( listen( listenfd , SOMAXCONN ) < 0 )
{
ERR_EXIT("listen") ;
}
std::vector<int>clients ;
int epollfd ;
epollfd = epoll_create1(EPOLL_CLOEXEC) ;
//epollfd = epoll_create1(0) ;
//EPOLL_CLOEXEC when the process is replaced , the file descriptor will be closed.

struct epoll_event event ;
event.data.fd = listenfd ;
event.events = EPOLLIN | EPOLLET ;
//EPOLLET edge triggered flip-flop,the default(EPOLLLT) is master-slave flip flop.
epoll_ctl ( epollfd , EPOLL_CTL_ADD , listenfd , &event ) ;

EventList events(16) ;
struct sockaddr_in peeraddr ;
socklen_t peerlen ;
int conn ;
int nready ;
while ( 1 )
{
nready = epoll_wait ( epollfd , &(*events.begin()) , static_cast<int>(events.size()) , -1 ) ;
// -1 means wait all the time until there is an event .
if ( -1 == nready )
{
if ( EINTR == errno )
{
continue ;
}
ERR_EXIT("epoll_wait") ;
}
if ( 0 == nready )
{
continue ;
}
if ( ( size_t ) nready == events.size() ) // not big enough , resize ...
{
events.resize(events.size()*2) ;
}
int i ;
for ( i = 0 ; i < nready ; i ++ )
{
if ( events[i].data.fd == listenfd )
{
struct sockaddr_in peeraddr ;
socklen_t peerlen ;
peerlen = sizeof(peeraddr) ;
conn = accept ( listenfd , ( struct sockaddr*) &peeraddr , &peerlen ) ;
//conn = accept ( listenfd , NULL , NULL ) ;
if ( -1 == conn )
{
ERR_EXIT("accept\n ") ;
}
printf("ip = %s port = %d\n" , inet_ntoa(peeraddr.sin_addr) , ntohs(peeraddr.sin_port) ) ;
printf ("count = %d\n" , ++count) ;
clients.push_back(conn) ;
activate_nonblock(conn) ;
event.data.fd =  conn ;
event.events = EPOLLIN|EPOLLET ;
epoll_ctl ( epollfd , EPOLL_CTL_ADD , conn , &event ) ;
}
else if ( events[i].events & EPOLLIN )
{
conn = events[i].data.fd ;
if ( conn < 0 )
{
continue ;
}
char recvbuf[1024] = {0} ;
int ret = readline(conn , recvbuf , 1024) ;
if ( -1 == ret )
{
ERR_EXIT("readline") ;
}
if ( 0 == ret )
{
printf ("client close\n") ;
close(conn) ;
event = events[i] ;
epoll_ctl ( epollfd , EPOLL_CTL_DEL , conn , &event ) ;
clients.erase(std::remove(clients.begin() , clients.end() , conn) , clients.end()) ;
}
fputs ( recvbuf , stdout ) ;
writen(conn , recvbuf , strlen(recvbuf)) ;
}
}
}
return 0 ;
}