我们紧接着上篇文章，看看我们上节课的代码有什么问题？
可以明显的看出来上节课的代码公用了一个同样的缓冲区进行读写，正常的情况下我们需要封装一个结构体，让每个对应的客户端的FD都有独立的结构进行读写还有接收连接。
具体的结构如下:
struct sock_item
{
//客户端的fd
int fd;
//读取的缓冲区
char * rbuffer;
//缓冲区的大小
int rlength;
//写入的缓冲区
char * wbuffer;
//写入的缓冲区大小
int wlength;
//处理的事件类型
int event;
//回调函数
void (*recv_cb)(int fd,char * buffer,int length);
void (*send_cb)(int fd,char *buffer,int length);
void (*accept_cb)(int fd,char * buffer,int length);
};
struct eventblock
{
struct sock_item * items;
struct eventblock*next;
};
struct reactor
{
int epfd;
int blkcnt;
struct eventblock *evblk;
};
首先看一下我的思路，如图所示
我们有一个总的reactor结构保存我们多个事件域。事件域中保存这我们的所有连接的客户端，而事件域就是一个链表的数据结构，我们无法知道我们要连入多少台客户端，因此我们要使用链表，当有超过我们的设置的1024个sock_item项，就再去申请一个新的事件域，保存新的sockitem。
上面，暂时解决了连接了很多个客户端FD的保存的问题，还有一个问题，就是我们一个IP端口可以连接的最大数为65535.
我们如何解决那？
一个连接都有5个元素来确定，一个源IP，一个源端口，一个目的IP，一个目的端口，协议的种类。
这里我们有3个方式来解决这个问题
第一个就是通过有多个网卡，就可以接受多个客户端的接入。
第二个就是通过绑定多个端口的方式，也可以接受多个客户端的接入。
第三个就是通过多个目的ip的端口更改，也是可以解决这个问题的，
我这个例子就是通过使用绑定多个端口来实现的。
初始化100个端口的代码
int init_server(short port){
int listenfd= socket(AF_INET,SOCK_STREAM,0);
if (listenfd==-1)
{
return -1;
}
struct sockaddr_in servaddr;
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(port);
if (-1==bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)))
{
return -2;
}
//设置非阻塞
int flag = fcntl(listenfd,F_GETFL,0);
flag |=O_NONBLOCK;
fcntl(listenfd,F_SETFL,flag);
listen(listenfd,10);
return listenfd;
}
判断是否是监听的FD的代码
int is_listenfd(int *fds,int connfd){
int i=0;
for (int i = 0; i < PORT_COUNT; i++)
{
if (fds[i] == connfd) {
return 1;
}
}
return 0;
}
现在初始化我们ractor结构并保存我们的fd。（主要就是链表的操作）
int reactor_resize(struct reactor *r ){
if (r==NULL)
{
return -1;
}
struct eventblock* blk=r->evblk;
while (blk!=NULL && blk->next!=NULL)
{
blk=blk->next;
}
struct sock_item * item=(struct sock_item *)malloc(ITEM_LENGTH * sizeof(struct sock_item));
if (item==NULL)
{
return -2;
}
memset(item,0,ITEM_LENGTH*sizeof(struct sock_item));
//链表增加的操作
struct eventblock * block=malloc(sizeof(struct eventblock));
if (block==NULL)
{
free(item);
return -3;
}
memset(block,0,sizeof(struct eventblock));
block->items=item;
block->next=NULL;
if (blk==NULL)
{
r->evblk=block;
}else
{
blk->next = block;
}
r->blkcnt ++;
return 0;
}
struct sock_item * reactor_lookup(struct reactor * r ,int sockfd)
{
if (r==NULL)
{
return NULL;
}
printf("currrent eventblock num:%d\n",r->blkcnt);
int blkidx=sockfd/ITEM_LENGTH;
while (blkidx >= r->blkcnt)
{
//如果当前的数目超过我们的最大数目 r->blkcnt * 1024; 重新申请一个block_event;
reactor_resize(r);
}
int i = 0;
struct eventblock* blk=r->evblk;
while (i ++ < blkidx && blk != NULL) {
blk = blk->next;
}
return &blk->items[sockfd % ITEM_LENGTH];
}
最后就是我们整个的一个代码
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<fcntl.h>
#include <unistd.h>
#include<sys/epoll.h>
#include <string.h>
#include <stdlib.h>
#define BUFFER_LENGTH 128
#define EVENTS_LENGTH 128
#define PORT_COUNT 200
#define ITEM_LENGTH 1024
struct sock_item
{
//客户端的fd
int fd;
//读取的缓冲区
char * rbuffer;
//缓冲区的大小
int rlength;
//写入的缓冲区
char * wbuffer;
//写入的缓冲区大小
int wlength;
//处理的事件类型
int event;
//回调函数
void (*recv_cb)(int fd,char * buffer,int length);
void (*send_cb)(int fd,char *buffer,int length);
void (*accept_cb)(int fd,char * buffer,int length);
};
struct eventblock
{
struct sock_item * items;
struct eventblock*next;
};
struct reactor
{
int epfd;
int blkcnt;
struct eventblock *evblk;
};
int init_server(short port){
int listenfd= socket(AF_INET,SOCK_STREAM,0);
if (listenfd==-1)
{
return -1;
}
struct sockaddr_in servaddr;
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(port);
if (-1==bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)))
{
return -2;
}
//设置非阻塞
int flag = fcntl(listenfd,F_GETFL,0);
flag |=O_NONBLOCK;
fcntl(listenfd,F_SETFL,flag);
listen(listenfd,10);
return listenfd;
}
int is_listenfd(int *fds,int connfd){
int i=0;
for (int i = 0; i < PORT_COUNT; i++)
{
if (fds[i] == connfd) {
return 1;
}
}
return 0;
}
int reactor_resize(struct reactor *r ){
if (r==NULL)
{
return -1;
}
struct eventblock* blk=r->evblk;
while (blk!=NULL && blk->next!=NULL)
{
blk=blk->next;
}
struct sock_item * item=(struct sock_item *)malloc(ITEM_LENGTH * sizeof(struct sock_item));
if (item==NULL)
{
return -2;
}
memset(item,0,ITEM_LENGTH*sizeof(struct sock_item));
//链表增加的操作
struct eventblock * block=(struct eventblock*)malloc(sizeof(struct eventblock));
if (block==NULL)
{
free(item);
return -3;
}
memset(block,0,sizeof(struct eventblock));
block->items=item;
block->next=NULL;
if (blk==NULL)
{
r->evblk=block;
}else
{
blk->next = block;
}
r->blkcnt ++;
return 0;
}
struct sock_item * reactor_lookup(struct reactor * r ,int sockfd)
{
if (r==NULL)
{
return NULL;
}
printf("currrent eventblock num:%d\n",r->blkcnt);
int blkidx=sockfd/ITEM_LENGTH;
while (blkidx >= r->blkcnt)
{
//如果当前的数目超过我们的最大数目 r->blkcnt * 1024; 重新申请一个block_event;
reactor_resize(r);
}
int i = 0;
struct eventblock* blk=r->evblk;
while (i ++ < blkidx && blk != NULL) {
blk = blk->next;
}
return &blk->items[sockfd % ITEM_LENGTH];
}
int main()
{
int ret;
//申请 reactor 结构
struct reactor * r= (struct reactor * )calloc(1,sizeof(struct reactor));
if (r==NULL)
{
return -3;
}
//开始进行EPOLL的创建
r->epfd= epoll_create(1);
struct epoll_event ev, events[EVENTS_LENGTH];
int sockfds[PORT_COUNT] = {0};
for (int i = 0; i < PORT_COUNT; i++)
{
sockfds[i] = init_server(9999 + i);
ev.events = EPOLLIN;
ev.data.fd = sockfds[i];
epoll_ctl(r->epfd, EPOLL_CTL_ADD, sockfds[i], &ev);
}
//接下来开始接受 我们的客户端的连接请求
while (1)
{
//我们需要详细讲解一下这个函数的里面的各个参数的意义 ，以及它什么时候是阻塞的，什么时候是非阻塞的，
//第一个参数我们的EPFD的文件描述符，第二个我们的接收事件的缓冲器，第三个是我们事件数量的多少，最后一个参数就是我们等待的时长了。
//当是-1的时候就是一直等待连接的意思，没有连接就会 一直被阻塞住，
//当是0的时候就是一直有连接直接返回的意思，
//当是大于0的数的时候，就是在轮询查看是否有事件的时长，单位是MS。
int nready = epoll_wait(r->epfd,events,EVENTS_LENGTH,-1);
printf("----------%d\n",nready);
//开始遍历我们的事件
int i =0;
for (int i = 0; i < nready; i++)
{
int clientfd=events[i].data.fd;
if (is_listenfd(sockfds,clientfd))
{
//如果是我们的监听的FD，说明是有客户端连入的事件
struct sockaddr_in client;
socklen_t len=sizeof(client);
//接受客户端的请求，
int connfd=accept(clientfd,(struct sockaddr*)&client,&len);
if (connfd==-1)
{
break;
}
int flag = fcntl(connfd, F_GETFL, 0);
flag |= O_NONBLOCK;
fcntl(connfd, F_SETFL, flag);
//增加到我们的快递柜中
ev.events=EPOLLIN;
ev.data.fd=connfd;
epoll_ctl(r->epfd,EPOLL_CTL_ADD,connfd,&ev);
//如果是读的请求
struct sock_item *item = reactor_lookup(r, connfd);
item->fd = connfd;
item->rbuffer = (char*)calloc(1, BUFFER_LENGTH);
item->rlength = 0;
item->wbuffer = (char*)calloc(1, BUFFER_LENGTH);
item->wlength = 0;
}
else if (events[i].events & EPOLLIN)
{
struct sock_item *item = reactor_lookup(r, clientfd);
char *rbuffer = item->rbuffer;
char *wbuffer = item->wbuffer;
int n = recv(clientfd, rbuffer, BUFFER_LENGTH, 0);
if (n > 0) {
//rbuffer[n] = '\0';
printf("recv: %s, n: %d\n", rbuffer, n);
memcpy(wbuffer, rbuffer, BUFFER_LENGTH);
ev.events = EPOLLOUT;
ev.data.fd = clientfd;
epoll_ctl(r->epfd, EPOLL_CTL_MOD, clientfd, &ev);
} else if (n == 0) {
free(rbuffer);
free(wbuffer);
item->fd = 0;
close(clientfd);
}
}
else if(events[i].events & EPOLLOUT)
{
struct sock_item *item = reactor_lookup(r, clientfd);
char *wbuffer = item->wbuffer;
int sent = send(clientfd, wbuffer, BUFFER_LENGTH, 0); //
printf("sent: %d\n", sent);
ev.events = EPOLLIN;
ev.data.fd = clientfd;
epoll_ctl(r->epfd, EPOLL_CTL_MOD, clientfd, &ev);
}
}
}
return 0;
}