libev客户端

 #include <ev.h>

 #include <stdio.h>

 #include <netinet/in.h>

 #include <stdlib.h>

 #include <string.h>

 #define PORT 6666

 #define BUFFER_SIZE 2048

 #define MAX_ALLOWED_CLIENT 10240

 struct ev_io *libevlist[MAX_ALLOWED_CLIENT] = {NULL};

 void accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents);

 void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents);

 void timer_beat(struct ev_loop *loop, struct ev_timer *watcher, int revents);

 int freelibev(struct ev_loop *loop, int fd);

 int main()

 {

     struct ev_loop *loop=ev_default_loop();

     int sd;

     struct sockaddr_in addr;

     int addr_len = sizeof(addr);

     //创建一个io watcher和一个timer watcher

     struct ev_io socket_accept;

     struct ev_timer timeout_w;

     //创建socket连接

     sd = socket(PF_INET, SOCK_STREAM, );

     if(sd < )

     {

         printf("socket error\n");

         return -;

     }

     bzero(&addr, sizeof(addr));

     addr.sin_family = AF_INET;

     addr.sin_port = htons(PORT);

     addr.sin_addr.s_addr = INADDR_ANY;

     //正常bind

     if(bind(sd, (struct sockaddr*)&addr, sizeof(addr)) != )

     {

         printf("bind error\n");

         return -;

     }

     //正常listen

     if(listen(sd, SOMAXCONN) < )

     {

         printf("listen error\n");

         return -;

     }

     //设置fd可重用

     int bReuseaddr=;

     if(setsockopt(sd,SOL_SOCKET ,SO_REUSEADDR,(const char*)&bReuseaddr,sizeof(bReuseaddr)) != )

     {

         printf("setsockopt error in reuseaddr[%d]\n", sd);

         return ;

     }

     //初始化io watcher，用于监听fd

     ev_io_init(&socket_accept, read_cb, sd, EV_READ);

     ev_io_start(loop, &socket_accept);

     ev_run(loop, );

     return ;

 }

 void accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)

 {

     //    如果有链接，则继续监听fd；

     struct sockaddr_in client_addr;

     socklen_t client_len = sizeof(client_addr);

     int client_sd;

     //创建客户端的io watcher

     struct ev_io *w_client = (struct ev_io*) malloc(sizeof(struct ev_io));

     if(w_client == NULL)

     {

         printf("malloc error in accept_cb\n");

         return ;

     }

     if(EV_ERROR & revents)

     {

         printf("error event in accept\n");

         return ;

     }

     //获取与客户端相连的fd

     client_sd = accept(watcher->fd, (struct sockaddr*)&client_addr, &client_len);

     if(client_sd < )

     {

         printf("accept error\n");

         return;

     }

     //如果连接数超出指定范围，则关闭连接

     if( client_sd > MAX_ALLOWED_CLIENT)

     {

         printf("fd too large[%d]\n", client_sd);

         close(client_sd);

         return ;

     }

     if(libevlist[client_sd] != NULL)

     {

         printf("client_sd not NULL fd is [%d]\n", client_sd);

         return ;

     }

     printf("client connected\n");

     //监听新的fd

     ev_io_init(w_client, read_cb, client_sd, EV_READ);

     ev_io_start(loop, w_client);

     libevlist[client_sd] = w_client;

 }

 void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)

 {

     char buffer[BUFFER_SIZE];

     ssize_t read;

     if(EV_ERROR & revents)

     {

         printf("error event in read\n");

         return ;

     }

     //正常的recv

     read = recv(watcher->fd, buffer, BUFFER_SIZE, );

     if(read < )

     {

         printf("read error\n");

         return;

     }

     if(read == )

     {

         printf("client disconnected.\n");

         //ev_io_stop(loop, watcher);

         //free(watcher);

         //如果客户端断开连接，释放响应的资源，并且关闭监听

         freelibev(loop, watcher->fd);

         return;

     }

     else

     {

         //buffer[read] = '\0';

         printf("receive message:%s\n", buffer);

     }

     //返回给客户端

     send(watcher->fd, buffer, read, );

     bzero(buffer, read);

 }

 int freelibev(struct ev_loop *loop, int fd)

 {

     //清理相关资源

     if(libevlist[fd] == NULL)

     {

         printf("the fd already freed[%d]\n", fd);

         return -;

     }

     close(fd);

     ev_io_stop(loop, libevlist[fd]);

     free(libevlist[fd]);

     libevlist[fd] = NULL;

     return ;

 }