从零开始学写HTTP服务器（五）IO复用使用epoll

爱被打了一巴掌 2022-07-13 03:12 174阅读 0赞

之前已经实现了一个及其简陋的HTTP服务器，今天花点时间改造了一下，用epoll来处理连接。

## **（一）epoll处理连接** ##

[I/O复用之epoll简介][I_O_epoll]中介绍了一种基于epoll的回射服务器程序。  
复习一下epoll的用法：  
主要有几个函数：

#include <sys/epoll.h>
    int epoll_create(int size);
    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

使用epoll编写TCP服务器可以参考linux man page：

#define MAX_EVENTS 10
               struct epoll_event ev, events[MAX_EVENTS];
               int listen_sock, conn_sock, nfds, epollfd;
    
               /* Set up listening socket, 'listen_sock' (socket(),
                  bind(), listen()) */
    
               epollfd = epoll_create(10);
               if (epollfd == -1) {
                   perror("epoll_create");
                   exit(EXIT_FAILURE);
               }
    
               ev.events = EPOLLIN;
               ev.data.fd = listen_sock;
               if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
                   perror("epoll_ctl: listen_sock");
                   exit(EXIT_FAILURE);
               }
    
               for (;;) {
                   nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
                   if (nfds == -1) {
                       perror("epoll_pwait");
                       exit(EXIT_FAILURE);
                   }
    
                   for (n = 0; n < nfds; ++n) {
                       if (events[n].data.fd == listen_sock) {
                           conn_sock = accept(listen_sock,
                                           (struct sockaddr *) &local, &addrlen);
                           if (conn_sock == -1) {
                               perror("accept");
                               exit(EXIT_FAILURE);
                           }
                           setnonblocking(conn_sock);
                           ev.events = EPOLLIN | EPOLLET;
                           ev.data.fd = conn_sock;
                           if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock,
                                       &ev) == -1) {
                               perror("epoll_ctl: conn_sock");
                               exit(EXIT_FAILURE);
                           }
                       } else {
                           do_use_fd(events[n].data.fd);
                       }
                   }
               }

--------------------

## **（二）代码** ##

在原来的基础进行了小小的修改。

### **2.1 httpserverepoll.cpp** ###

#include "socketapi.h"
    #include "httpapi.h"
    #include "epollapi.h"
    
    using namespace std;
    
    int main(int argc, char **argv)
    {
        const int port = 1025;
        int listenfd=socket(af_inet,sock_stream,0);
    
        struct sockaddr_in servaddr;
    
        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family      = af_inet;
        servaddr.sin_addr.s_addr = htonl(inaddr_any);
        servaddr.sin_port        = htons(port);
    
        bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
    
        listen(listenfd, listenq);
        do_epoll(listenfd);
        return 0;
    }

### **2.2 sockAPI.cpp** ###

包裹函数来自于unp

### **2.3 httpAPI.cpp** ###

对其中一些代码进行了简单的修改

#include "httpAPI.h"
    //获取请求方法和请求uri
    void getRequestHead(char *buffer,int msgLen,string &method,string&uri)
    {
       stringstream ss(string(buffer,buffer+msgLen)) ;
       ss>>method;
       ss>>uri;
    }
    
    //根据不同的请求方法执行,能力问题不支持post
    void do_response(int sockfd,string method,string uri,string &content,string&responseheader)
    {
        if(method=="POST")
        {
        //do_post_response();
        }
        else if(method=="HEAD")
        {
        //跟get类似仅仅返回响应头不返回内容
    //  do_head_response();
        }
        else //default GET 
        {
            do_get_response(sockfd,method,uri,content,responseheader);
        }
    }
    
    //发送响应
    void do_get_response(int sockfd,string method,string uri,string &content,string &responseheader)
    {
        string contentType;
        string statusCode;
        content=getContent(statusCode,uri,contentType);
        responseheader=constructHeader(statusCode,content,contentType);
    
    #if 0
        //发送响应头
        send(sockfd,responseHeader.c_str(),responseHeader.size(),0);
        //发送响应报文
        send(sockfd,content.c_str(),content.size(),0);
    #endif
    
    }
    
    //获取content
    string getContent(string &statusCode,string uri,string &contentType)
    {
        string fileName=parseURI(uri);
        //解析content-type
        parseContentType(fileName,contentType);
        ifstream f(fileName);//打开文件
        if(f.fail())//no such file
        {
            statusCode="404 Not Found";
            return errorContent();
        }
        string tmp;
        string content;
        while(f>>tmp)
        {
            content+=tmp;
        }
        statusCode="200 OK";
        f.close();
        return content;
    }
    //打开一个errorpage
    string errorContent()
    {
        ifstream f("error.html");
        string tmp;
        string content;
        while(f>>tmp)
        {
            content+=tmp;
        }
        f.close();
        return content;
    }
    //解析uri
    string parseURI(string uri)
    {
        //    string webroot=getConf();
        //    简单起见不设置conf文件
        if(uri=="/")
        uri+="index.html";
        string webroot="/home/zhangxiao/zxtest/myhttpd/httpserverepoll";
        return webroot+uri;
    }
    
    //解析Content-type
    void parseContentType(string fileName,string &contentType)
    {
        string tmpExtension=getExtent(fileName);
        ifstream mimeFile("mime.types");
        string line;
        while(NULL!=getline(mimeFile,line))
        {
            if(line[0]!='#')
            {
                stringstream lineStream(line);
                contentType.clear();
                lineStream>>contentType;
                vector<string>extensions;
                string extension;
                while(lineStream>>extension)
                {
                    extensions.push_back(extension);
                }
                for(int i=0;i<extensions.size();++i)
                {
                    if(tmpExtension==extensions[i])
                    {
                        mimeFile.close();
                        return ;
                    }
                }
    
            }
        }
        //如果都不匹配就默认为text/plain
        contentType="text/plain";
        mimeFile.close();
    }
    //获取文件扩展名
    string getExtent(string fileName)
    {
        int i;
        for(i=fileName.size()-1;;--i)
        {
            if(fileName[i]=='.')
                break;
        }
        return string(fileName.begin()+i+1,fileName.end());
    }
    //构造响应头
    string constructHeader(string status,const string& content,const string &contentType)
    {
    
        string statusCode(status);
        string contentSize(std::to_string(content.size()));
        string head("\r\nHTTP/1.1 ");
        string ContentType("\r\nContent-Type: ");
        string ServerHead("\r\nServer: localhost");
        string ContentLength("\r\nContent-Length: ");
        string Date("\r\nDate: ");
        string Newline("\r\n");
        time_t rawtime;
        time(&rawtime);
        string message;
        message+=head;
        message+=statusCode;
        message+=ContentType;
        message+=contentType;
        message+=ServerHead;
        message+=ContentLength;
        message+=contentSize;
        message+=Date;
        message+=(string)ctime(&rawtime);
        message+=Newline;
        return message;
    }

### **2.4 epollAPI.cpp** ###

对epoll调用进行了简单的包裹函数封装

#include "epollAPI.h"
    void do_epoll(int listenfd)
    {
        int epollfd;
        struct epoll_event events[EPOLLEVENTS];
        int ret;
        //epoll create
        epollfd = epoll_create(FDSIZE);
        string content;
        string responseheader;
    
        add_event(epollfd,listenfd,EPOLLIN);
        for ( ; ; )
        {
        //epoll_wait
            ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1);
        //ret nums of fds
            handle_events(epollfd,events,ret,listenfd,content,responseheader);
        }
        close(epollfd);
    }
    void add_event(int epollfd,int fd,int state)
    {
        struct epoll_event ev;
        ev.events = state;//EPOLL_IN
        ev.data.fd = fd;
        epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&ev);//add fd
    }
    
    void
    handle_events(int epollfd,struct epoll_event *events,int num,int listenfd,string &content,string&responseheader)
    {
        int i;
        int fd;
        for (i = 0;i < num;i++)
        {
            fd = events[i].data.fd;
            if ((fd == listenfd) &&(events[i].events & EPOLLIN))
                handle_accpet(epollfd,fd);
            else if (events[i].events & EPOLLIN)
                do_read(epollfd,fd,content,responseheader);
            else if (events[i].events & EPOLLOUT)
                do_write(epollfd,fd,content,responseheader);
        }
    }
    void handle_accpet(int epollfd,int listenfd)
    {
        int clifd;
        struct sockaddr_in cliaddr;
        socklen_t  cliaddrlen=sizeof(cliaddr);
    
        clifd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen);
        if (clifd == -1)
            perror("accpet error:");
        else
        {
            printf("accept a new client: %s:%d\n",inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
            add_event(epollfd,clifd,EPOLLIN);
        }
    }
    
    
    
    void do_read(int epollfd,int fd,string &content,string &responseheader)
    {
        int msgLen;
        char buffer[BUFFER_SIZE];
        memset(buffer,0x00,BUFFER_SIZE);
        if ((msgLen = recv(fd, buffer, BUFFER_SIZE, 0)) == -1)
        {
            printf("Error handling incoming request");
            close(fd);
            delete_event(epollfd,fd,EPOLLIN);
            return ;
        }
        else if(msgLen==0)
        {
            printf("client closed\r\n");
            close(fd);
            delete_event(epollfd,fd,EPOLLIN);
        }
        else
        {
            string method;
            string uri;
            getRequestHead(buffer,msgLen,method,uri);
            do_response(fd,method,uri,content,responseheader);
            modify_event(epollfd,fd,EPOLLOUT);
        }
    }
    void do_write(int epollfd,int fd,const string&content,const string&responseheader )
    {
        //发送响应头
        send(fd,responseheader.c_str(),responseheader.size(),0);
        //发送响应报文
        send(fd,content.c_str(),content.size(),0);
    
        delete_event(epollfd,fd,EPOLLOUT);
        close(fd);
    }
    void delete_event(int epollfd,int fd,int state)
    {
        struct epoll_event ev;
        ev.events = state;
        ev.data.fd = fd;
        epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,&ev);
    }
    void modify_event(int epollfd,int fd,int state)
    {
        struct epoll_event ev;
        ev.events = state;
        ev.data.fd = fd;
        epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&ev);
    }

--------------------

## **（三）参考** ##

1 unp  
2.[http://blog.csdn.net/zhangxiao93/article/details/52849349?locationNum=1&fps=1][I_O_epoll]  
3.图解http

[I_O_epoll]: http://blog.csdn.net/zhangxiao93/article/details/52849349?locationNum=1&fps=1