linux epoll ET边沿触发

/*
*
*EPOLL ET 触发必须使用非阻塞，LT触发可以阻塞/非阻塞。
*read 函数 非阻塞读需 忙轮寻 soket关闭返回0，循环读完数据
*如果已经读完再读read返回 -1，errno=11(EAGIAN)则退出轮循
*
**/

#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/select.h>
#include<sys/time.h>
#include<pthread.h>
#include<memory.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<signal.h>
#include<semaphore.h>
#include<malloc.h>
#include<fcntl.h>
#include<sys/epoll.h>

typedef unsigned int uint32;

pthread_mutex_t lock;
uint32 qcount=;

typedef struct{
    int flag;
    sem_t sem;
}MYLOCK;

struct sockaddr_in server;
MYLOCK mlock;
int g_epfd=-;

void printerror()
{
    printf("%d:%s\n",errno,strerror(errno));
    exit(-);
}

void* th_hand(void* p){
    sem_wait(&mlock.sem);
    while(!mlock.flag){
        sem_post(&mlock.sem);
        sleep();
        sem_wait(&mlock.sem);
    }
    sem_post(&mlock.sem);
    struct epoll_event events[];
    struct epoll_event event;
    while(){
        memset(&event,,sizeof(struct epoll_event));
        memset(events,,sizeof(struct epoll_event)*);
        int s = epoll_wait(g_epfd,events,,);
        if(s==-){
            printerror();
        }else if(s==){
            continue;
        }else if(s>){
            for(int i=;i<s;i++){
                int fd=events[i].data.fd;
                char buff[];
                while(){
                int rd=-;
                memset(buff,,sizeof(buff));
                rd=read(fd,buff,sizeof(buff)-);
                if(rd==){
                    struct sockaddr_in client;
                    memset(&client,,sizeof(client));
                    int len=sizeof(client);
                    getpeername(fd,(struct sockaddr*)&client,&len);
                    printf("client %s is closed fd is %d , bye!\n",inet_ntoa(client.sin_addr),fd);
                    close(fd);
                    event.data.fd=fd;

                    sem_post(&mlock.sem);
                    epoll_ctl(g_epfd,EPOLL_CTL_DEL,fd,&event);
                    sem_wait(&mlock.sem);
                    break;
                }else if(rd>){
                    int wr=write(STDOUT_FILENO,buff,rd);
                }else if(rd==-){
                    if(errno==EAGAIN)
                        break;
                    printerror();
                }
                }
            }
        }
    }
}
int initSocket(int port){
    memset(&server,,sizeof(server));
    server.sin_family=AF_INET;
    server.sin_addr.s_addr=htonl(INADDR_ANY);//INADDR_ANY==0
    server.sin_port=htons(port);
    int sockfd=socket(AF_INET,SOCK_STREAM,);
    if(sockfd==-){
        printerror();
    }
    int res=bind(sockfd,(struct sockaddr*)&server,sizeof(struct sockaddr));
    if(res==-){
        printerror();
    }
    if(-==listen(sockfd,)){
        printerror();
    }

    g_epfd=epoll_create();
    if(g_epfd==-){
        printerror();
    }

    sem_wait(&mlock.sem);
        mlock.flag=;
    sem_post(&mlock.sem);

    printf("main before accept\n");
    while(){
        int fd;
        if((fd=accept(sockfd,NULL,NULL))==-){
            printerror();
        }
        printf("fd %d is connect\n",fd);
        struct epoll_event event;
//        event.events=EPOLLIN;
        event.events=EPOLLIN|EPOLLET;
        event.data.fd=fd;

        fcntl(fd,F_SETFL,fcntl(fd,F_GETFL,)|O_NONBLOCK);

        sem_wait(&mlock.sem);
        if(-==(epoll_ctl(g_epfd,EPOLL_CTL_ADD,fd,&event))){
            printerror();
        }
        qcount++;
        sem_post(&mlock.sem);
    }
}

void sig_hand(int signo){
    if(signo==SIGINT){
        printf("have %d client\n",qcount);
        exit();
    }
}

pthread_t pid;

int main(int argc,char** argv){
    if(argc<){
        puts("please input port\n");
        exit(-);
    }
    int port=atoi(argv[]);
    signal(SIGINT,sig_hand);
    memset(&mlock,,sizeof(mlock));
    sem_init(&mlock.sem,,);
    mlock.flag=;
    pthread_create(&pid,NULL,th_hand,(void*));
    pthread_detach(pid);
    initSocket(port);        

}