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; }