int run_child(int idx , client_data* users , char* share_mem)
{
epoll_event events[MAX_EVENT_NUMBER];
int child_epollfd = epoll_create(5);
assert(child_epollfd != -1);
int connfd = users[idx].connfd;
addfd(child_epollfd , connfd);
int pipefd = users[idx].pipefd[1];
addfd(child_epollfd , pipefd);
int ret;
addsig(SIGTERM , child_term_handler , false);
while(!stop_child){
int number = epoll_wait(child_epollfd , events , MAX_EVENT_NUMBER , -1);
if((number < 0) &&(errno != EINTR)){
printf("epoll failure\n");
break;
}
for(int i = 0 ; i < number ; i++){
int sockfd = events[i].data.fd;
if((sockfd == connfd) &&(events[i].events & EPOLLIN)){
memset(share_mem + idx*BUFFER_SIZE , '\0' , BUFFER_SIZE);
ret = recv(connfd , share_mem + idx*BUFFER_SIZE , BUFFER_SIZE-1 , 0);
if(ret < 0){
if(errno != EAGAIN){
stop_child = true;
}
}else if(ret == 0){
stop_child = true;
}else{
send(pipefd , (char*)&idx , sizeof(idx) , 0);
}
}
//主进程通过管道将第client个客户的数据发送到本进程负责的客户端
else if((sockfd == pipefd) && (events[i].events & EPOLLIN)){
int client = 0;
ret = recv(sockfd , (char*)&client , sizeof(client) , 0);
if(ret < 0){
if(errno != EAGAIN){
stop_child = true;
}
}else if(ret == 0){
stop_child = true;
}else{
send(connfd , share_mem + client*BUFFER_SIZE , BUFFER_SIZE , 0);
}
}
}
close(connfd);
close(pipefd);
close(child_epollfd);
return 0;
}
}
int main(int argc, char* argv[]){
if(argc <= 2){
printf("usage: %s ip_address port_number\n", basename(argv[0]));
return 1;
}
const char* ip = argv[1];
int port = atoi(argv[2]);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int listenfd = sockfd(PF_INET, SOCK_STREAM, 0);
assert(listenfd >= 0);
int ret = 0;
ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(listenfd, 5);
assert(ret != -1);
epoll_event events[MAX_EVENT_NUMBER];
int epollfd = epoll_create(5);
assert(epollfd != -1);
addfd(epollfd, listenfd, false);
while(1){
ret = epoll_wait(epollfd, &events, MAX_EVENT_NUMBER, -1);
if(ret < 0){
printf("epoll failure\n");
continue;
}
for(int i = 0; i < ret; i++){
int sockfd = events[i].data.fd;
if(sockfd == listenfd){
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
/*对每个非监听描述符都注册EPOLLONESHOT事件*/
addfd(epollfd, connfd, true);
} else if(events[i].events & EPOLLIN) {
pthread_t thread;
fds fds_for_new_worker;
fds_for_new_worker.sockfd = sockfd;
fds_for_new_worker.epollfd = epollfd;
/*启动一个新线程为sockfd服务*/
pthread_create(&thread, NULL, worker, (void *)&fds_for_new_worker);
} else {
printf("something else happened\n");
}
}
}
close(listenfd);
return 0;
}
//the level-trigger logic
void lt(struct epoll_event *events, int number, int epollfd, int listenfd)
{
char buf[BUF_SIZE];
int i;
for(i = 0; i < number; i++)
{
int sockfd = events[i].data.fd;
//new client connection
if(sockfd == listenfd){
struct sockaddr_in client_addr;
socklen_t client_addrlen = sizeof(client_addr);
int connfd = accept(listenfd, (struct sockaddr *)&client_addr, &client_addrlen);
if(connfd < 0){
perror("accept failed..");
exit(-1);
}
//register this event
addfd(epollfd, connfd, 0);
}else if(events[i].events & EPOLLIN){
//if there exists data unreaded , this code will invoke
printf("sockefd %d read event trigger once\n", sockfd);
int ret = recv(sockfd, buf, BUF_SIZE, 0);
if(ret <= 0){
printf("some read error or client closed.\n");
close(sockfd); // will unregister
continue;
}
printf("get %d bytes from client: %s\n", ret, buf);
}else{
// what we are not interested
printf("something else happened\n");
}
}
}
void lt( epoll_event* events, int number, int epollfd, int listenfd )
{
char buf[ BUFFER_SIZE ];
for ( int i = 0; i < number; i++ )
{
int sockfd = events[i].data.fd;
if ( sockfd == listenfd )
{
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof( client_address );
int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
addfd( epollfd, connfd, false );
}
else if ( events[i].events & EPOLLIN )
{
printf( "event trigger once\n" );
memset( buf, '\0', BUFFER_SIZE );
int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
if( ret <= 0 )
{
close( sockfd );
continue;
}
printf( "get %d bytes of content: %s\n", ret, buf );
}
else
{
printf( "something else happened \n" );
}
}
}
//lt模式的工作流程
void lt(struct epoll_event* events,int number,int epollfd,int listenfd)
{
char buf[_BUF_SIZE_];
int i=0;
for(i=0;i<number;i++)
{
int sockfd=events[i].data.fd;
if(sockfd==listenfd)
{
struct sockaddr_in client;
socklen_t len =sizeof(client);
int connfd=accept(listenfd,(struct sockaddr*)&client,&len);
addfd(epollfd,connfd,false);
}
else if(events[i].events&EPOLLIN)
{
//只要sock读缓存中还有未读出的数据，这段代码就被触发i
printf("###################ltlt################\n");
memset(buf,'\0',_BUF_SIZE_);
int ret=recv(sockfd,buf,_BUF_SIZE_-1,0);
if(ret<=0)
{
close(sockfd);
continue;
}
printf("get %d bytes of content:%s\n",ret,buf);
}
else{
printf("something else happend\n");
}
}
}
void id_process(int fd, short revents, void *data){
int err;
unsigned char *b;
struct sockaddr_rc addr_them;
char cmd[100];
socklen_t addrLength = sizeof(addr_them);
struct connectioninfo *ci;
UNUSED(data);
if(revents&POLLHUP || revents&POLLNVAL){
close(fd);
removefd(head, fd);
return;
}
err = getpeername(fd, (struct sockaddr *)&addr_them, &addrLength);
if(err < 0){
perror("failed to get socket name");
exit(-1);
}
b = addr_them.rc_bdaddr.b;
sprintf(cmd, "hcitool name %02x:%02x:%02x:%02x:%02x:%02x", b[5], b[4], b[3], b[2], b[1], b[0]);
FILE *f = popen(cmd, "r");
ci = malloc(sizeof(struct connectioninfo));
ci->socket = fd;
ci->pipe = f;
memcpy(&ci->addr_them, &addr_them, sizeof(struct sockaddr_rc));
addfd(head, fileno(f), POLLIN, id_greeting, ci);
}
void start_conn( int epoll_fd, int num, const char* ip, int port )
{
int ret = 0;
struct sockaddr_in address;
bzero( &address, sizeof( address ) );
address.sin_family = AF_INET;
inet_pton( AF_INET, ip, &address.sin_addr );
address.sin_port = htons( port );
for ( int i = 0; i < num; ++i )
{
//sleep( 1 );
int sockfd = socket( PF_INET, SOCK_STREAM, 0 );
printf( "create 1 sock\n" );
if( sockfd < 0 )
{
continue;
}
if ( connect( sockfd, ( struct sockaddr* )&address, sizeof( address ) ) == 0 )
{
printf( "build connection %d\n", i );
addfd( epoll_fd, sockfd );
}
}
}
void service::init(int sockfd,const sockaddr_in& addr)
{
m_sockfd=sockfd;
m_address=addr;
addfd(m_epollfd,sockfd,true);
m_user_count++;
init();
}
int main(int argc,char **argv)
{
printf("Http server welcome you!\n");
tpool_create(10);
if(1!=argc)
getoption(argc,argv);//It's hard to learn how to use it
if(NULL==_log)
logfd=open(DEFAULTLOG,O_WRONLY | O_APPEND | O_CREAT);
else
logfd=open(_log,O_WRONLY | O_CREAT | O_APPEND);
daytime();
int sockfd,sockfds;
if(daemon_check)
daemons();
ssl_init(ctx);
signal(SIGPIPE,SIG_IGN);
signal(SIGCHLD, SIG_IGN);
sockfd=make_socket(sockfd);
sockfds=make_socket_ssl(sockfds);
if(sockfd<0||sockfds<0)
errorfunc("sockfd error!");
int addrlen = 1;
setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&addrlen,sizeof(addrlen));//set the port quickly reuse
setsockopt(sockfds,SOL_SOCKET,SO_REUSEADDR,&addrlen,sizeof(addrlen));
struct epoll_event events[MAXEVENTS];//question
int epollfd=epoll_create(MAXEVENTS);
addfd(epollfd,sockfd,0);
addfd(epollfd,sockfds,0);
chdir("/home/wangyao/web");
while(1)
{
int ret=epoll_wait(epollfd,events,MAXEVENTS,-1);//epoll func should be use in here
if(ret<0)
errorfunc("epoll_wait error!");
lt(events,ret,epollfd,sockfd,sockfds);
}
close(sockfds);
close(sockfd);
close(epollfd);
sleep(10);
tpool_destroy();
SSL_CTX_free(ctx);
exit(0);
}
int main(int argc, char **argv)
{
int socket;
#define MAX_POLL 256
struct pollfd fds[MAX_POLL];
UNUSED(argc);
UNUSED(argv);
registerService();
socket = createListening(10);
head = addfd(head, socket, POLLIN, echo_connect, 0); // first creation
socket = createListening(11);
addfd(head, socket, POLLIN, id_connect, 0);
socket = createListeningL2cap(0x1011); // must be > 0x1001 and odd
addfd(head, socket, POLLIN, l2_connect, 0);
while(1){
int n = mkpoll(head, fds, MAX_POLL);
if(poll(fds, n, -1)){
struct fdlist *fdl = head;
int i;
for(i = 0; i < n; i++){
if(fds[i].revents){
while(fdl && fdl->fd != fds[i].fd)
fdl = fdl->next;
assert(fdl);
fdl->hanlder(fds[i].fd, fds[i].revents, fdl->ptr);
}
}
}
else {
perror("Poll failed");
exit(-1);
}
}
return 0;
}
int main(int argc,char *argv[])
{
if(argc<3)
{
printf("usage:%s [ip] [port]\n");
}
char *ip=argv[1];
int port=atoi(argv[2]);
struct sockaddr_in local;
bzero(&local,sizeof(local));
local.sin_family=AF_INET;
local.sin_addr.s_addr=inet_addr(ip);
local.sin_port=htons(port);
int ret;
int sock=socket(AF_INET,SOCK_STREAM,0);
assert(sock>=0);
int opt=1;
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
ret=bind(sock,(struct sockaddr*)&local,sizeof(local));
assert(ret=-1);
ret=listen(sock,5);
assert(ret=-1);
struct epoll_event events[_EVENT_NUMS_];
int epollfd=epoll_create(256);
assert(epollfd!=-1);
addfd(epollfd,sock,true);
int timeout=5000;
while(1)
{
int ret=epoll_wait(epollfd,events,_EVENT_NUMS_,timeout);
if(ret<0)
{
printf("epoll_wait faild\n");
break;
}
else if(ret==0)
{
printf("timeout\n");
continue;
}
// lt(events,ret,epollfd,sock);
et(events,ret,epollfd,sock);
}
close(sock);
return 0;
}
void ModeET(epoll_event* events,int number,int epollfd,int listenfd)
{
char buf[BUFFSIZE];
for(int i =0; i <number;i++)
{
int sockfd = events[i].data.fd;
if(sockfd == listenfd)
{
struct sockaddr_in client_addr;
socklen_t client_addrlen = sizeof(client_addr);
int connfd = accept(listenfd,(struct sockaddr*)&client_addr,&client_addrlen);
addfd(epollfd,connfd,true);
}
else if(events[i].events & EPOLLIN)
{
std::cout <<"event trigger once" <<std::endl;
while(1)
{
memset(buf,BUFFSIZE-1,0);
int ret = recv(sockfd,buf,BUFFSIZE-1,0);
if(ret < 0)
{
if((errno = EAGAIN) ||(errno == EWOULDBLOCK))
{
std::cout <<"read latter" <<std::endl;
break;
}
close(sockfd);
break;
}
else if(ret ==0)
{
close(sockfd);
}
else
{
std::cout <<"get " <<ret <<"bytes" <<std::endl;
std::cout <<"the content"<<buf<<std::endl;
}
}
}
else
{
std::cout <<"something else happened"<<std::endl;
}
}
}
int main (int argc, char *argv[])
{
int sfd, s;
int efd;
struct epoll_event event;
struct epoll_event events[MAXEVENTS];
if (argc < 2){
fprintf (stderr, "Usage: %s [port]\n", basename(argv[0]));
exit (EXIT_FAILURE);
}
// const char *ip = argv[1];
// int port = atoi(argv[2]);
sfd = create_and_bind (argv[1]);
if (sfd == -1) abort ();
//listen for connection coming
s = listen (sfd, SOMAXCONN);
if (s == -1) {
perror ("listen");
abort ();
}
//create a epoll object
efd = epoll_create1 (0);
if (efd == -1) {
perror ("epoll_create");
abort ();
}
//add the listen socket to the event poll
addfd(efd, sfd, 1);
while(1)
{
int ret = epoll_wait(efd, events, MAXEVENTS, -1);
if(ret < 0){
printf("epoll wait failture..\n");
break;
}
//et(events, ret, efd, sfd);
lt(events, ret, efd, sfd);
}
close (sfd);
return EXIT_SUCCESS;
}
void et(struct epoll_event* events,int number,int epollfd,int listenfd)
{
char buf[_BUF_SIZE_];
int i=0;
for (i=0;i<number;i++)
{
int sockfd=events[i].data.fd;
if(sockfd==listenfd)
{
struct sockaddr_in client;
socklen_t len=sizeof(client);
int connfd=accept(listenfd,(struct sockaddr*)&client,&len);
addfd(epollfd,connfd,true);
}
else if(events[i].events&EPOLLIN)
{
printf("**************etetet*********************\n");
//这段代码不会被重复触发，所以我们循环读取数据，以确保把socket读缓存中的所有数据读出
while(1)
{
memset(buf,'\0',_BUF_SIZE_);
int ret=recv(sockfd,buf,_BUF_SIZE_-1,0);
if(ret<0)
{
//对于非阻塞IO，下面的条件成立表示数据已经全部读取完毕，此后，epoll就能再次触发sockfd上的EPOLLIN事件，以驱动下一次读操作
if((errno==EAGAIN)||(errno==EWOULDBLOCK))
{
printf("read later\n");
break;
}
close(sockfd);
break;
}
else if(ret==0)
{
close(sockfd);
}
else{
printf("get %d bytes of content:%s\n",ret,buf);
}
}
}
else
{
printf("something else happen\n");
}
}
}
//the edge-trigger logic
void et(struct epoll_event *events, int number, int epollfd, int listenfd)
{
char buf[BUF_SIZE];
int i;
for(i = 0; i < number; i++)
{
int sockfd = events[i].data.fd;
//new client connection
if(sockfd == listenfd){
struct sockaddr_in client_addr;
socklen_t client_addrlen = sizeof(client_addr);
int connfd = accept(listenfd, (struct sockaddr *)&client_addr, &client_addrlen);
if(connfd < 0){
perror("accept failed..");
exit(-1);
}
//register this event and set edge trigger mode
addfd(epollfd, connfd, 1);
}else if(events[i].events & EPOLLIN){
//in this mode , we should read all the data out once
printf("sockefd %d read event trigger once\n", sockfd);
while(1)
{
memset(buf, 0, sizeof(buf));
int ret = recv(sockfd, buf, BUF_SIZE, 0);
if(ret < 0){
//for the nonblocking IO,the following errors indicate the read complete
if(errno == EAGAIN || errno == EWOULDBLOCK){
printf("read later\n");
break;
}
printf("some other error\n");
close(sockfd); // will unregister
break;
}else if(ret == 0){
printf("client closed.\n");
close(sockfd);
break;
}else{
printf("get %d bytes from client: %s\n", ret, buf);
}
}
}else{
// what we are not interested
printf("something else happened\n");
}
}
}
void proc_accept(int sfd, int arg) {
int fd, conn;
struct sockaddr_in addr;
int alen;
alen = sizeof(addr);
if ((fd = accept(sfd,(struct sockaddr *)&addr,&alen)) < 0) {
logmsg("bad accept: %s",strerror(errno));
return;
}
if ((conn = nidServer_newConn(fd)) < 0) {
logmsg("bad incoming call");
return;
}
addfd(fd,proc_pkt,conn);
}
int main( int argc, char* argv[] )
{
if( argc <= 2 )
{
printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
return 1;
}
const char* ip = argv[1];
int port = atoi( argv[2] );
int ret = 0;
struct sockaddr_in address;
bzero( &address, sizeof( address ) );
address.sin_family = AF_INET;
inet_pton( AF_INET, ip, &address.sin_addr );
address.sin_port = htons( port );
int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
assert( listenfd >= 0 );
ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
assert( ret != -1 );
ret = listen( listenfd, 5 );
assert( ret != -1 );
epoll_event events[ MAX_EVENT_NUMBER ];
int epollfd = epoll_create( 5 );
assert( epollfd != -1 );
addfd( epollfd, listenfd, true );
while( 1 )
{
int ret = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, -1 );
if ( ret < 0 )
{
printf( "epoll failure\n" );
break;
}
lt( events, ret, epollfd, listenfd );
// et( events, ret, epollfd, listenfd );
}
close( listenfd );
return 0;
}
void start_conn(int epoll_fd,int num, const char* ip, int port,char *localip)
{
int ret = 0;
struct sockaddr_in address;
bzero(&address,sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET,ip,&address.sin_addr);
address.sin_port = htons(port);
printf("connect ip :%s\n",localip);
for( int i = 0; i < num; ++i)
{
//sleep(1);
struct timespec time1;
time1.tv_sec=0;
time1.tv_nsec=100000L;
nanosleep(&time1,NULL);
int sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd < 0 )
{
printf("error on create socket errno =%d:\t%s\n",errno,strerror(errno));
continue;
}
struct sockaddr_in clnt_addr;
bzero(&clnt_addr,sizeof(clnt_addr));
clnt_addr.sin_family= AF_INET;
clnt_addr.sin_addr.s_addr = inet_addr(localip);
clnt_addr.sin_port=htons(i+1024);
if(bind(sockfd,(struct sockaddr *) &clnt_addr,sizeof(clnt_addr)) < 0)
{
printf("error on binding %s,errno=%d:\t%s\n",localip,errno,strerror(errno));
continue;
}
printf("create 1 sock \n");
if(connect(sockfd,(struct sockaddr*) &address,sizeof(address)) == 0)
{
printf("bulid connection %d\n",i);
addfd(epoll_fd,sockfd);
}
}
}
void et( epoll_event* events, int number, int epollfd, int listenfd )
{
char buf[ BUFFER_SIZE ];
for ( int i = 0; i < number; i++ )
{
int sockfd = events[i].data.fd;
if ( sockfd == listenfd )
{
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof( client_address );
int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
addfd( epollfd, connfd, true );
}
else if ( events[i].events & EPOLLIN )
{
printf( "event trigger once\n" );
while( 1 )
{
memset( buf, '\0', BUFFER_SIZE );
int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
if( ret < 0 )
{
if( ( errno == EAGAIN ) || ( errno == EWOULDBLOCK ) )
{
printf( "read later\n" );
break;
}
close( sockfd );
break;
}
else if( ret == 0 )
{
close( sockfd );
}
else
{
printf( "get %d bytes of content: %s\n", ret, buf );
}
}
}
else
{
printf( "something else happened \n" );
}
}
}
int main (int argc,char* argv[])
{
if(argc <=2)
{
std::cout <<"ip + port" <<std::endl;
exit(0);
}
const char* ip = argv[1];
int port = atoi(agrv[2]);
int ret =0;
struct sockaddr_in server_addr;
memset(server_addr,0,sizeof(sockaddr_in));
server_addr.sin_family = PF_INET;
inet_pton(AF_INET,ip,&server_addr.sin_addr);
server_addr.sin_port = htons(port);
int listenfd = socket(PF_INET,SOCK_STREAM,0);
assert(listenfd >= 0);
ret = bind(listenfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
assert(ret > 0);
ret = listen(listenfd,5);
epoll_event events[MAX_EVENT_NUMBER];
int epollfd =epoll_create(5);
assert(epollfd != -1);
addfd(epollfd,listenfd,true);
while(1)
{
int ret = epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-1);
if( ret < 0)
{
std::cout << "epoll error" <<std::endl;
break;
}
ModeLT(events,ret,epollfd,listenfd);
//ModeET(events,ret,epollfd,listenfd);
}
close(listenfd);
return 0;
}
bool CepollServer::InitServer(int port)
{
m_listenAddr.sin_family = AF_INET;
m_listenAddr.sin_addr.s_addr = htonl(INADDR_ANY);
m_listenAddr.sin_port = htons(port);
//create listen socket;
m_listenfd = socket(AF_INET,SOCK_STREAM,0);
if(m_listenfd<0)
{
perror("create socket failed!");
return false;
}
//支持端口复用
int iReuseaddr_on = 1;
setsockopt(m_listenfd,SOL_SOCKET,SO_REUSEADDR,&iReuseaddr_on,sizeof(iReuseaddr_on) );
//bind
if(0!=bind(m_listenfd,(sockaddr*)&m_listenAddr,sizeof(m_listenAddr)))
{
perror("bind failed!");
return false;
}
//listen
if(0!=listen(m_listenfd,10))
{
perror("listen failed!");
return false;
}
//create epoll
m_efd = epoll_create(EPOLL_SIZE);
//set no block
if(0>fcntl(m_efd,F_SETFL,O_NONBLOCK))
{
perror("set no block failed!");
return false;
}
//add listen socket to epoll
addfd(m_listenfd);
return true;
}
void l2_connect(int fd, short revents, void *data){
struct sockaddr_l2 addr;
unsigned char *a;
socklen_t length = sizeof(struct sockaddr_l2);
UNUSED(revents);
UNUSED(data);
printf("L2 connect started\n");
int sk = accept(fd, (struct sockaddr *)&addr, &length);
a = addr.l2_bdaddr.b;
printf("Connect from: %02x:%02x:%02x:%02x:%02x:%02x port %d\n", a[5], a[4], a[3], a[2], a[1], a[0], addr.l2_psm);
addfd(head, sk, POLLIN|POLLHUP|POLLNVAL, l2_process, 0);
l2_process(sk, POLLIN, 0x0);
}
void echo_connect(int fd, short revents, void *data){
struct sockaddr_rc addr;
unsigned char *a;
socklen_t length = sizeof(struct sockaddr_rc);
UNUSED(data);
UNUSED(revents);
printf("Echo connect started\n");
int sk = accept(fd, (struct sockaddr *)&addr, &length);
a = addr.rc_bdaddr.b;
printf("Connect from: %02x:%02x:%02x:%02x:%02x:%02x port %d\n", a[5], a[4], a[3], a[2], a[1], a[0], addr.rc_channel);
addfd(head, sk, POLLIN|POLLHUP|POLLNVAL, echo_process, 0);
}
/*server::server() {
cout<<"welcome"<<endl;
}*/
void server::start()
{
listensocket=socket(AF_INET,SOCK_STREAM,0);
ser_addr.sin_family = AF_INET;
ser_addr.sin_port = htons(8888);
ser_addr.sin_addr.s_addr = INADDR_ANY;
bind(listensocket,(struct sockaddr*)&ser_addr,sizeof(ser_addr));
listen(listensocket,MAX_SIZE);
epfd = epoll_create(MAX_SIZE);
if(epfd < 0) {
perror("epfd error");
exit(-1);
}
addfd(epfd, listensocket);
}
int main(int argc, char **argv) {
int i,fd,tmout = -1;
openlog("nid",LOG_PID,LOG_DAEMON);
nidLogToSyslog(1);
/* redirect stderr */
if ((fd = open("/tmp/nid_server.err",O_WRONLY|O_APPEND|O_CREAT,0644)) >= 0) {
close(2);
dup2(fd,2);
close(fd);
}
if ((i = nidRegister(0)) < 0) {
logmsg("bad incoming call");
exit(1);
}
/* driver initialization should add itself to any loops */
for(i = 0; drivers[i]; i++)
drivers[i]->init(drivers[i]);
addfd(0,proc_pkt,0); /* setup handler for incoming requests */
/* process fd events from here on in */
while (1) {
/* calculate timeout in msecs */
long tm1, tm2, basetmout;
basetmout = (int)(1000/update_rate);
if (tmout <= 0) {
if (!compress)
nidServer_flushEvents(0);
tmout = basetmout;
tm1 = now();
}
scan(tmout);
tm2 = now();
tmout = basetmout - (tm2 - tm1); /* subtract elapsed time */
}
exit(0);
}
void *server_thread(void *z) {
int tmout = 0;
addfd(0,proc_pkt,0);
/* process fd events from here on in */
while (1) {
/* calculate timeout in msecs */
long tm1, tm2, basetmout;
VE_DEBUG(2,("server thread loop"));
basetmout = (int)(1000/update_rate);
if (tmout <= 0) {
VE_DEBUG(2,("flushing events"));
nidServer_flushEvents(0);
tmout = basetmout;
tm1 = now();
}
VE_DEBUG(2,("waiting for activity/timeout (tmout = %d)",tmout));
scan(tmout);
tm2 = now();
tmout = basetmout - (tm2 - tm1); /* subtract elapsed time */
}
return NULL;
}
void ModeLT(epoll_event* events,int number,int epollfd,int listenfd)
{
char buf[BUFFSIZE];
for(int i =0; i <number; i++)
{
int sockfd = events[i].data.fd;
if(sockfd == listenfd) // 如果时间是监听套接字上发生地事件
{
struct sockaddr_in client_addr;
socklen_t client_addrlen = sizeof(client_addr);
int connfd = accept(listenfd,(struct sockaddr*)&client_addr,&client_addrlen);
addfd(epollfd,connfd,false); // 对connfd 禁用 ET模式
}
else if(events[i].events & EPOLLIN)
{
std::cout << "event trigger once" << std::endl;
memset(buf,BUFFSIZE,0);
ssize_t ret = recv(sockfd,buf,BUFFSIZE-1,0);
if(ret < 0)
{
close(sockfd);
continue;
}
std::cout<<"get " <<ret <<"bytes from ckient" <<std:: endl;
std::cout<< "content:"<<buf<<std::endl;
}
else
{
std::cout <<"something else happened"<<std::endl;
}
}
}
void server::process()
{
static struct epoll_event events[MAX_SIZE];
while(1)
{
//epoll_events_count表示就绪事件的数目
int epoll_events_count = epoll_wait(epfd, events,MAX_SIZE, -1);
if(epoll_events_count < 0) {
perror("epoll failure");
break;
}
cout << "epoll_events_count =\n" << epoll_events_count << endl;
//处理这epoll_events_count个就绪事件
for(int i = 0; i < epoll_events_count; ++i)
{
int sockfd = events[i].data.fd;
//新用户连接
if(sockfd == listensocket)
{
struct sockaddr_in client_address;
socklen_t client_addrLength = sizeof(struct sockaddr_in);
int clientfd = accept( listensocket, ( struct sockaddr* )&client_address, &client_addrLength );
addfd(epfd, clientfd);
client.push_back(clientfd);
}
else
{
readClient(sockfd);
}
}
}
}
void start_conn(int epoll_fd, int num, const char* ip , int port, int space)
{
if(num <= 0 || port <= 0 || space <= 0)
{
exit(0);
}
struct sockaddr_in address;
bzero(&address,sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET,ip,&address.sin_addr);
address.sin_port = htons(port);
for(int i = 0; i < num ; ++i)
{
if((i % space) == 0)
{
sleep(1); // 1s
}
int sockfd = socket(PF_INET, SOCK_STREAM,0);
if(sockfd < 0)
{
continue;
}
if( connect(sockfd, (struct sockaddr*)&address, sizeof(address)))
{
printf("build connection %d\n",i);
addfd(epoll_fd,sockfd);
}
else
{
printf("create failed\n");
}
}
}
int main( int argc, char* argv[] )
{
if( argc <= 2 )
{
printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
return 1;
}
const char* ip = argv[1];
int port = atoi( argv[2] );
int ret = 0;
struct sockaddr_in address;
bzero( &address, sizeof( address ) );
address.sin_family = AF_INET;
inet_pton( AF_INET, ip, &address.sin_addr );
address.sin_port = htons( port );
listenfd = socket( PF_INET, SOCK_STREAM, 0 );
assert( listenfd >= 0 );
ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
assert( ret != -1 );
ret = listen( listenfd, 5 );
assert( ret != -1 );
for( int i = 0; i < PROCESS_COUNT; ++i )
{
ret = socketpair( PF_UNIX, SOCK_STREAM, 0, sub_process[i].pipefd );
assert( ret != -1 );
sub_process[i].pid = fork();
if( sub_process[i].pid < 0 )
{
continue;
}
else if( sub_process[i].pid > 0 )
{
close( sub_process[i].pipefd[1] );
setnonblocking( sub_process[i].pipefd[0] );
continue;
}
else
{
close( sub_process[i].pipefd[0] );
setnonblocking( sub_process[i].pipefd[1] );
run_child( i );
exit( 0 );
}
}
epoll_event events[ MAX_EVENT_NUMBER ];
epollfd = epoll_create( 5 );
assert( epollfd != -1 );
addfd( epollfd, listenfd );
ret = socketpair( PF_UNIX, SOCK_STREAM, 0, sig_pipefd );
assert( ret != -1 );
setnonblocking( sig_pipefd[1] );
addfd( epollfd, sig_pipefd[0] );
addsig( SIGCHLD, sig_handler );
addsig( SIGTERM, sig_handler );
addsig( SIGINT, sig_handler );
addsig( SIGPIPE, SIG_IGN );
bool stop_server = false;
int sub_process_counter = 0;
while( !stop_server )
{
int number = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, -1 );
if ( ( number < 0 ) && ( errno != EINTR ) )
{
printf( "epoll failure\n" );
break;
}
for ( int i = 0; i < number; i++ )
{
int sockfd = events[i].data.fd;
if( sockfd == listenfd )
{
int new_conn = 1;
send( sub_process[sub_process_counter++].pipefd[0], ( char* )&new_conn, sizeof( new_conn ), 0 );
printf( "send request to child %d\n", sub_process_counter-1 );
sub_process_counter %= PROCESS_COUNT;
}
else if( ( sockfd == sig_pipefd[0] ) && ( events[i].events & EPOLLIN ) )
{
int sig;
char signals[1024];
ret = recv( sig_pipefd[0], signals, sizeof( signals ), 0 );
if( ret == -1 )
{
continue;
}
else if( ret == 0 )
{
continue;
}
else
{
for( int i = 0; i < ret; ++i )
{
switch( signals[i] )
{
case SIGCHLD:
{
pid_t pid;
int stat;
while ( ( pid = waitpid( -1, &stat, WNOHANG ) ) > 0 )
{
for( int i = 0; i < PROCESS_COUNT; ++i )
{
if( sub_process[i].pid == pid )
{
close( sub_process[i].pipefd[0] );
sub_process[i].pid = -1;
}
}
}
stop_server = true;
for( int i = 0; i < PROCESS_COUNT; ++i )
{
if( sub_process[i].pid != -1 )
{
stop_server = false;
}
}
break;
}
case SIGTERM:
case SIGINT:
{
printf( "kill all the clild now\n" );
for( int i = 0; i < PROCESS_COUNT; ++i )
{
int pid = sub_process[i].pid;
kill( pid, SIGTERM );
}
break;
}
default:
{
break;
}
}
}
}
}
else
{
continue;
}
}
}
del_resource();
return 0;
}
