HttpHandler.cpp

#include <algorithm>
#include <cassert>
#include <cstring>
#include <cctype>
#include <fcntl.h>
#include <netinet/in.h>
#include <sstream>
#include <sys/mman.h>
#include <sys/prctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>

#include "HttpHandler.h"
#include "Log.h"
#include "Utils.h"

// 声明一下该静态成员变量
 // 如果先前没有设置 www 路径,则设置路径为当前的工作路径
string HttpHandler::www_path = ".";

HttpHandler::HttpHandler(Epoll* epoll, int client_fd, Timer* timer) 
      // 初始化 client 的 fd 和 epoll event
    : client_fd_(client_fd), client_event_{client_fd_, this}, 
      // 初始化 timer 的 fd 和 epoll event
      timer_(timer), epoll_(epoll), curr_parse_pos_(0)
{
    // HTTP1.1下,默认是持续连接
    // 除非 client http headers 中带有 Connection: close
    isKeepAlive_ = true;
    // 初始化一些变量
    reset();
    // 设置 timer epoll event
    if(timer)
        timer_event_ = {timer->getFd(), this};
}

HttpHandler::~HttpHandler()
{
    // 从 epoll 中删除该套接字相关的事件
    /// NOTE: 注意先删除 epoll 中的条目,再来关闭 fd
    bool ret1 = epoll_->del(client_fd_);
    bool ret2 = true;
    // 如果不是空定时器,则释放
    if(timer_)
    {
        ret2 = epoll_->del(timer_->getFd());
        // 删除定时器
        delete timer_;
    }
    assert(ret1 && ret2);
    // 关闭客户套接字
    INFO("------------------------ "
         "Connection Closed (socket: %d)"
         "------------------------",
         client_fd_);
    close(client_fd_);
}

void HttpHandler::reset()
{
    // 清除已经处理过的数据
    assert(request_.length() >= curr_parse_pos_);

    request_.clear();
    curr_parse_pos_ = 0;
    // 重设状态
    state_ = STATE_PARSE_URI;
    // 重置重试次数
    againTimes_ = maxAgainTimes;
    // 重置 headers_
    headers_.clear();
    // 重置 body
    http_body_.clear();
    // 重置超时时间
    if(timer_)
        timer_->setTime(timeoutPerRequest, 0);
}

HttpHandler::ERROR_TYPE HttpHandler::readRequest()
{
    INFO("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
         "- Request Packet -"
         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ");

    char buffer[MAXBUF];
    
    while(true)
    {
        // 非阻塞,使用 recv 读取
        ssize_t len = recv(client_fd_, buffer, MAXBUF, MSG_DONTWAIT);
        if(len < 0) {
            // 读取时没有出错
            if(errno == EAGAIN)
                return ERR_SUCCESS;
            else if(errno == EINTR)
                continue;
            return ERR_READ_REQUEST_FAIL;
        }
        else if(len == 0)
        {
            // 如果读取到的字节数为0,则说明 EOF, 远程连接已经被关闭
            return ERR_CONNECTION_CLOSED;
        }

        // 将读取到的数据组装起来
        string request(buffer, buffer + len);
        INFO("{%s}", escapeStr(request, MAXBUF).c_str());

        request_ += request;
    }
    return ERR_SUCCESS;
}

HttpHandler::ERROR_TYPE HttpHandler::parseURI()
{
    size_t pos1, pos2;
    
    pos1 = request_.find("\r\n");
    if(pos1 == string::npos)    return ERR_AGAIN;
    string&& first_line = request_.substr(0, pos1);
    // a. 查找get
    pos1 = first_line.find(' ');
    if(pos1 == string::npos)    return ERR_BAD_REQUEST;
    string methodStr = first_line.substr(0, pos1);

    string output_method = "Method: ";
    if(methodStr == "GET")
        method_ = METHOD_GET;
    else if(methodStr == "POST")
        method_ = METHOD_POST;
    else if(methodStr == "HEAD")
        method_ = METHOD_HEAD;
    else
        return ERR_NOT_IMPLEMENTED;
    INFO("Method: %s", methodStr.c_str());

    // b. 查找目标路径
    pos1++;
    pos2 = first_line.find(' ', pos1);
    if(pos2 == string::npos)    return ERR_BAD_REQUEST;

    // 获取path时,注意加上 www path
    path_ = www_path + "/" + first_line.substr(pos1, pos2 - pos1);
    // 检测目录穿越
    if(!is_path_parent(www_path, path_))
        return ERR_NOT_FOUND;
    
    INFO("Path: %s", path_.c_str());

    // c. 查看HTTP版本
    pos2++;
    string http_version_str = first_line.substr(pos2, first_line.length() - pos2);
    INFO("HTTP Version: %s", http_version_str.c_str());

    // 检测是否支持客户端 http 版本
    if(http_version_str == "HTTP/1.0")
        http_version_ = HTTP_1_0;
    else if (http_version_str == "HTTP/1.1")
        http_version_ = HTTP_1_1;
    else
        return ERR_HTTP_VERSION_NOT_SUPPORTED;

    // 更新curr_parse_pos_
    curr_parse_pos_ += first_line.length() + 2;
    return ERR_SUCCESS;
}

HttpHandler::ERROR_TYPE HttpHandler::parseHttpHeader()
{
    INFO("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
         "- Request Info -"
         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

    size_t pos1, pos2;
    for(pos1 = curr_parse_pos_;
        (pos2 = request_.find("\r\n", pos1)) != string::npos;
        pos1 = pos2 + 2)
    {
        string&& header = request_.substr(pos1, pos2 - pos1);
        // 如果遍历到了空头,则表示http header部分结束
        if(header.size() == 0)
        {
            curr_parse_pos_ = pos1 + 2;
            return ERR_SUCCESS;
        }
        pos1 = header.find(' ');

        if(pos1 == string::npos)    return ERR_BAD_REQUEST;

        // key 的格式： `XXX:`
        string&& key = header.substr(0, pos1);

        // 消除key里的最后一个冒号字符
        if(key.size() < 2 || key.back() != ':') return ERR_BAD_REQUEST;
        key.pop_back();

        // key 转小写
        transform(key.begin(), key.end(), key.begin(), ::tolower);
        // 获取 value
        string&& value = header.substr(pos1 + 1);

        INFO("HTTP Header: [%s : %s]", key.c_str(), value.c_str());

        headers_[key] = value;
    }

    // 执行到这里说明: 没有遍历到空头,即还有数据没有读完
    return ERR_AGAIN;
}

HttpHandler::ERROR_TYPE HttpHandler::parseBody()
{
    assert(method_ == METHOD_POST);
    
    auto content_len_iter = headers_.find("content-length");
    if(content_len_iter == headers_.end())
        return ERR_LENGTH_REQUIRED;

    string len_str = content_len_iter->second;
    if(!isNumericStr(len_str))
        return ERR_BAD_REQUEST;

    int len = atoi(len_str.c_str());

    if(request_.length() < curr_parse_pos_ + len)
        return ERR_AGAIN;
    http_body_ = request_.substr(curr_parse_pos_, len);

    // 输出剩余的 HTTP body
    INFO("HTTP Body: {%s}", escapeStr(http_body_, MAXBUF).c_str());

    return ERR_SUCCESS;    
}

HttpHandler::ERROR_TYPE HttpHandler::handleRequest()
{
    // 设置只在 HTTP/1.1时 默认允许 持续连接
    if(http_version_ == HTTP_1_0)
        isKeepAlive_ = false;

    // 获取header完成后,处理一下 Connection 头
    auto conHeaderIter = headers_.find("connection");
    if(conHeaderIter != headers_.end())
    {
        string value = conHeaderIter->second;
        transform(value.begin(), value.end(), value.begin(), ::tolower);
        if(value == "keep-alive")
            isKeepAlive_ = true;
    }

    // 获取目标文件的信息
    struct stat st;
    if(stat(path_.c_str(), &st) == -1)
    {
        WARN("Can not get file [%s] state ! (%s)", path_.c_str(), strerror(errno));
        if(errno == ENOENT)
            return ERR_NOT_FOUND;
        else
            return ERR_INTERNAL_SERVER_ERR;
    }
    // 如果试图打开一个文件夹,则添加 index.html
    if (S_ISDIR(st.st_mode)) {
        path_ += "/index.html";
        if(stat(path_.c_str(), &st) == -1)
        {
            WARN("Can not get file [%s] state ! (%s)", path_.c_str(), strerror(errno));
            if(errno == ENOENT)
                return ERR_NOT_FOUND;
            else
                return ERR_INTERNAL_SERVER_ERR;
        }
    }

    // 开始处理请求
    // 对于普通的 GET / HEAD 请求,读取文件并发送
    if(method_ == METHOD_GET || method_ == METHOD_HEAD)
    {
        // 试图打开一个文件
        int file_fd;
        if((file_fd = open(path_.c_str(), O_RDONLY, 0)) == -1)
        {
            WARN("File [%s] open failed ! (%s)", path_.c_str(), strerror(errno));
            if(errno == ENOENT)
                // 如果打开失败,则返回404
                return ERR_NOT_FOUND;
            else
                // 如果是因为其他问题出错，则返回500
                return ERR_INTERNAL_SERVER_ERR;
        }  
        // 读取文件, 使用 mmap 来高速读取文件
        void* addr = mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, file_fd, 0);
        // 记得关闭文件描述符
        close(file_fd); 
        // 异常处理
        if(addr == MAP_FAILED)
        {
            WARN("Can not map file [%s] -> mem! (%s)", path_.c_str(), strerror(errno));
            return ERR_INTERNAL_SERVER_ERR;
        }
        // 将数据从内存页存入至 responseBody
        char* file_data_ptr = static_cast<char*>(addr);
        string responseBody(file_data_ptr, file_data_ptr + st.st_size);
        // 记得删除内存
        int res = munmap(addr, st.st_size);
        if(res == -1)
            WARN("Can not unmap file [%s] -> mem! (%s)", path_.c_str(), strerror(errno));
        // 获取 Content-type
        string suffix = path_;
        // 通过循环找到最后一个 dot
        size_t dot_pos;
        while((dot_pos = suffix.find('.')) != string::npos)
            suffix = suffix.substr(dot_pos + 1);

        // 发送数据, 在该函数内部, METHOD_HEAD 不发送 http body
        return sendResponse("200", "OK", MimeType::getMineType(suffix), responseBody);
    }
    // 而对于POST来说,将 http body 传入目标可执行文件并将结果返回给客户端
    /**
     * @brief 多进程调试
     *  gdb: set follow-fork-mode parent
     *       set detach-on-fork off
     *  shell: 
     *       查看某个进程的pid:          ps ax | grep "WebServer" 
     *       查看某个pid的文件描述符列表:  lsof -p <PID>
     *       查看WebServer的所有子进程:  pstree -p -g <WebServerPID>
     */
    else if(method_ == METHOD_POST)
    {
        // 创建两个管道
        int cgi_output[2];
        int cgi_input[2];
        /**
         * NOTE: 创建管道时，一定要指定 O_CLOEXEC
         * 因为当当前线程 thread1 执行 fork 产生子进程 subproc1 后，
         * subproc1 会同步继承这些其他线程 thread2 用于其他进程 subproc2 通信的管道
         * 这样当 thread2 关闭了向 subproc2 写入数据的管道 pipe2w 后，
         * 由于 subproc1 保存了 pipe2w，因此实际上该管道不会被销毁
         * 所以 subproc2 将无法从 pipe2w 中读取数据，因为管道没有关闭，不存在EOF
         * 
         * NOTE: 即便创建管道时指定了 O_CLOEXEC
         * 但实际上，在子进程中执行 dup2 操作时，新复制出的文件描述符将不会继承 O_CLOEXEC，
         * 这样我们就可以达到：关闭所有的进程间通信管道，只保留当前子进程的输入输出管道，这样的一个目的
         */ 
        if (pipe2(cgi_output, O_CLOEXEC) == -1) {
            WARN("cgi_output create error. (%s)", strerror(errno));
            return ERR_INTERNAL_SERVER_ERR;
        }
        if (pipe2(cgi_input, O_CLOEXEC) == -1) {
            WARN("cgi_input create error. (%s)", strerror(errno));
            // 记得关闭之前的管道
            close(cgi_output[0]);
            close(cgi_output[1]);
            return ERR_INTERNAL_SERVER_ERR;
        }
        // 尝试执行该CGI程序
        pid_t pid;
        /**
         * @note 需要注意的是 fork 在多进程中要慎重使用
         * @ref 谨慎使用多线程中的fork https://www.cnblogs.com/liyuan989/p/4279210.html
         * @ref 程序员的自我修养（三）：fork() 安全 https://liam.page/2017/01/17/fork-safe/
         */ 
        if((pid = fork()) < 0)
        {
            WARN("Fork error. (%s)", strerror(errno));
            close(cgi_input[0]);
            close(cgi_input[1]);
            close(cgi_output[0]);
            close(cgi_output[1]);
            return ERR_INTERNAL_SERVER_ERR;
        }
        // 对于子进程来说
        if(pid == 0)
        {
            /**
             * 将当前进程的进程号设置为所在组的进程组的组号
             * 这有助于WebServer 杀死子进程
             * 
             * kill -pid 时会杀死 PGID为 `-pid` 的所有子进程
             * 因此可以利用 setpgid 来达到区分进程的目的
             * 
             * 正常来说,如果没有设置 setpgid,则WebServer所有的子进程,以及子进程的子进程
             * 其PGID都为WebServer的PID,这为杀死 pid为某个特定值的子进程以及该子进程的子进程巨大障碍
             * 因此在子进程处需要重新设置 pgid
             */
            // 正常来说, setpgid 不可能会失败.如果失败了就直接abort
            // 因为设置失败将会导致该子进程无法受到父进程的超时限制
            if(setpgid(0, 0) == -1)
                FATAL("setpgid fail in child process! (%s)", strerror(errno));
            // 设置当父进程死亡时，子进程同步死亡
            if(prctl(PR_SET_PDEATHSIG, SIGKILL) == -1)
                FATAL("prctl fail in child process! (%s)", strerror(errno));
            // 首先重新设置标准输入输出流
            // 注意 dup2 会自动关闭当前打开的 fd0、fd1 和 fd2
            if(dup2(cgi_input[0], 0) == -1 
                || dup2(cgi_output[1], 1) == -1 
                || dup2(1, 2) == -1)
                FATAL("dup2 fail! (%s)", strerror(errno));
            close(cgi_input[0]);
            close(cgi_input[1]);
            close(cgi_output[0]);
            close(cgi_output[1]);

            // 准备参数
            char path[path_.size() + 1];
            strcpy(path, path_.c_str());
            char* const args[] = { path, NULL };

            // 此时已经完成了所有的准备，现在准备执行目标程序

            // 执行
            execve(path, args, environ);
            // 如果执行到这里，则说明出现了问题
            FATAL("execve fail in child process! (%s)", strerror(errno));
        }
        // 对于父进程WebServer来说
        else
        {
            close(cgi_input[0]);
            close(cgi_output[1]);

            // 将 HTTP body 写入 CGI 程序的标准输入中
            ssize_t len = writen(cgi_input[1], http_body_.c_str(), http_body_.length(), true);
            // 如果写入失败
            if(len <= 0)
                WARN("Write %ld bytes to CGI input fail! (%s)", http_body_.length(), strerror(errno));

            close(cgi_input[1]);

            // 设置超时时间 maxCGIRuntime(ms)
            int timeouts = maxCGIRuntime;
            /**
             * @brief 进入一个死循环,只有当子进程退出后才会break
             * @note 该循环将会有2条执行流程
             *          1. 执行子进程 -> waitpid -> 子进程退出 -> 结束循环;
             *          2. 执行子进程 -> waitpid -> 子进程没有退出
             *              -> 超时 -> kill -> waitpid -> 子进程退出 -> 结束循环;
             */
            while(true)
            {
                // 单次休息 cgiStepTime(ms)
                if(!usleep(cgiStepTime * 1000))
                    timeouts -= cgiStepTime;
                int wstats = -1;
                int waitpid_ret = waitpid(pid, &wstats, WNOHANG);
                // 如果waitpid 出错
                if(waitpid_ret < 0)
                {
                    WARN("waitpid error. (%s)", strerror(errno));
                    // ret 前,一定一定一定要关闭这个读取端口
                    close(cgi_output[0]);
                    return ERR_INTERNAL_SERVER_ERR;
                }
                // 如果子进程状态被修改, 当子进程状态改变后,waitpid 才会设置 status, 否则 status 不变
                else if(waitpid_ret > 0)
                {
                    // 只有在子进程自然退出,或者子进程被 kill 时,才会处理,退出该循环
                    // 至于其他情况,例如子进程遇到了 SIGINT,则忽视
                    bool ifExited = WIFEXITED(wstats);
                    // 注意 SIGKILL 会 terminate 子进程,因此使用 WTERMSIG 来获取TERSIG
                    // 这里不指定是 SIGKILL信号,因为可能有其他信号会kill子进程
                    bool ifKilled = WIFSIGNALED(wstats) && (WTERMSIG(wstats) != 0);
                    if(ifExited || ifKilled)
                        break;
                }
                // 如果什么也没有发生, 即子进程仍然在跑.如果顺便超时了,则kill
                else if(timeouts <= 0)
                {
                    /** 
                     * @brief 把 kill 放到循环内部是为了 waitpid 回收子进程
                     * NOTE: -pid 指的是杀死当前子进程以及该子进程自身的子进程,例如shell脚本
                     * NOTE: 再kill一次 pid 是为了防止子进程太久没有轮到执行,仍然处于fork与execl之间的状态
                     *       此时,之前的 kill -pid 将会不起作用.因此为了确保子进程一定被kill,需要再kill一次pid
                     */        
                    int res_kill_sub = kill(pid, SIGKILL);
                    int res_kill_pgid = 0;
                    // 只有在子进程的pgid变化后才kill -pid,防止误伤其他线程中的子进程
                    if(getpgid(pid) == pid)
                        res_kill_pgid = kill(-pid, SIGKILL);
                    assert(!res_kill_sub && !res_kill_pgid);
                    WARN("Sub process timeout.");
                }
            }

            // 走到这里则说明程序已经执行结束了
            string responseBody;
            char buf[MAXBUF];
            // 非阻塞读取
            if(!setFdNoBlock(cgi_output[0]))
            {
                WARN("set fd(%d) no block fail! (%s)", cgi_output[0], strerror(errno));
                close(cgi_output[0]);
                return ERR_INTERNAL_SERVER_ERR;
            }
            while((len = readn(cgi_output[0], buf, MAXBUF)) > 0)
                responseBody += string(buf, buf + len);
            close(cgi_output[0]);

            if(responseBody.empty())
                return ERR_INTERNAL_SERVER_ERR;
            // 发送数据
            return sendResponse("200", "OK", MimeType::getMineType("txt"), responseBody);
        }
    }
    else
        return ERR_INTERNAL_SERVER_ERR;
    UNREACHABLE();
    return ERR_SUCCESS;
}

bool HttpHandler::handleErrorType(HttpHandler::ERROR_TYPE err)
{
    // 除了 ERR_SUCESS 和 ERR_AGAIN 没有设置 state 以外, 其他 case 都设置了 state_
    bool isSuccess = false;
    switch(err)
    {
    case ERR_SUCCESS:
        isSuccess = true;
        /* 注意这里没有设置 STATE */
        break;
    case ERR_READ_REQUEST_FAIL:
        ERROR("HTTP Read request failed ! (%s)", strerror(errno));
        state_ = STATE_FATAL_ERROR;
        break;
    case ERR_AGAIN:
        --againTimes_;
        INFO("HTTP waiting for more messages...");
        /* 注意这里没有设置 STATE , 与 ERR_SUCESS一样 */
        if(againTimes_ <= 0)
        {
            state_ = STATE_FATAL_ERROR;
            WARN("Reach max read times");
        }
        break;
    case ERR_CONNECTION_CLOSED:
        INFO("HTTP Socket(%d) was closed.", client_fd_);
        state_ = STATE_FATAL_ERROR;
        break;
    case ERR_SEND_RESPONSE_FAIL:
        ERROR("Send Response failed !");
        state_ = STATE_FATAL_ERROR;
        break;
    case ERR_BAD_REQUEST:
        WARN("HTTP Bad Request.");
        sendErrorResponse("400", "Bad Request");
        state_ = STATE_ERROR;
        break;
    case ERR_NOT_FOUND:
        WARN("HTTP Not Found.");
        sendErrorResponse("404", "Not Found");
        state_ = STATE_ERROR;
        break;
    case ERR_LENGTH_REQUIRED:
        WARN("HTTP Length Required.");
        sendErrorResponse("411", "Length Required");
        state_ = STATE_ERROR;
        break;
    case ERR_NOT_IMPLEMENTED:
        WARN("HTTP Request method is not implemented.");
        sendErrorResponse("501", "Not Implemented");
        state_ = STATE_ERROR;
        break;
    case ERR_INTERNAL_SERVER_ERR:
        WARN("HTTP Internal Server Error.");
        sendErrorResponse("500", "Internal Server Error");
        state_ = STATE_ERROR;
        break;
    case ERR_HTTP_VERSION_NOT_SUPPORTED:
        WARN("HTTP Request HTTP Version Not Supported.");
        sendErrorResponse("505", "HTTP Version Not Supported");
        state_ = STATE_ERROR;
        break;
    default:
        UNREACHABLE();
    }
    return isSuccess;
}

HttpHandler::ERROR_TYPE HttpHandler::sendResponse(const string& responseCode, const string& responseMsg, 
                            const string& responseBodyType, const string& responseBody)
{
    stringstream sstream;
    sstream << "HTTP/1.1" << " " << responseCode << " " << responseMsg << "\r\n";
    sstream << "Connection: " << (isKeepAlive_ ? "Keep-Alive" : "Close") << "\r\n";
    if(isKeepAlive_)
        // Keep-Alive 头中, timeout 表示超时时间(单位s), max表示最多接收请求次数,超过则断开.
        sstream << "Keep-Alive: timeout=" << timeoutPerRequest << ", max=" << againTimes_ << "\r\n";
    sstream << "Server: WebServer/1.1" << "\r\n";
    sstream << "Content-length: " << responseBody.size() << "\r\n";
    sstream << "Content-type: " << responseBodyType << "\r\n";
    sstream << "\r\n";
    // 如果是 HEAD 请求,则不发送 http body
    if(method_ != METHOD_HEAD)
        sstream << responseBody;

    string&& response = sstream.str();

    ssize_t len = writen(client_fd_, (void*)response.c_str(), response.size());

    // 输出返回的数据
    INFO("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<- Response Packet ->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ");
    INFO("{%s}", escapeStr(response, MAXBUF).c_str());

    if(len < 0 || static_cast<size_t>(len) != response.size())
        return ERR_SEND_RESPONSE_FAIL;
    return ERR_SUCCESS;
}

HttpHandler::ERROR_TYPE HttpHandler::sendErrorResponse(const string& errCode, const string& errMsg)
{
    string errStr = errCode + " " + errMsg;
    string responseBody = 
                "<html>"
                "<title>" + errStr + "</title>"
                "<body>" + errStr + 
                    "<hr><em> Kiprey's Web Server</em>"
                "</body>"
                "</html>";
    return sendResponse(errCode, errMsg, "text/html", responseBody);
}

bool HttpHandler::RunEventLoop()
{
    // 从socket读取请求数据, 如果读取失败,或者断开连接
    if(!handleErrorType(readRequest()))
        // 直接断开连接
        return false;
    
    // 解析信息 ------------------------------------------
    // 1. 先解析第一行
    if(state_ == STATE_PARSE_URI && handleErrorType(parseURI()))
        state_ = STATE_PARSE_HEADER;
    // 2. 解析每一条http header
    if(state_ == STATE_PARSE_HEADER && handleErrorType(parseHttpHeader()))
        state_ = STATE_PARSE_BODY;
    // 3. 对于 post 解析 http body
    if(state_ == STATE_PARSE_BODY)
    {
        if(method_ != METHOD_POST || handleErrorType(parseBody()))
            state_ = STATE_ANALYSI_REQUEST;
    }
    // 4. 开始处理数据
    if(state_ == STATE_ANALYSI_REQUEST && handleErrorType(handleRequest()))
        state_ = STATE_FINISHED;

    // 开始处理当前状态
    // 如果这个过程中有任何非致命错误, 或者当前过程圆满结束
    if(state_ == STATE_ERROR || state_ == STATE_FINISHED)
    {
        // 如果 keep Alive, 则重置状态, 并跳出 if 到最后的return 处重新放入 epoll 中
        if(isKeepAlive_)
            reset();
        else 
            // 否则,既然已经发生了错误 / 完成了请求,则直接销毁当前实例
            return false;
    }
    // 如果是致命错误,则直接返回 false
    else if(state_ == STATE_FATAL_ERROR)
        return false;

    // 执行到这里则表示需要更多数据,因此重新放入 epoll 中
    bool ret1 = true;
    if(timer_)
        ret1 = epoll_->modify(timer_->getFd(), getTimerEpollEvent(), getTimerTriggerCond());
    bool ret2 = epoll_->modify(client_fd_, getClientEpollEvent(), getClientTriggerCond());
    assert(ret1 && ret2);

    return true;
}