1.需要实现的项目需求（web服务器的工作原理）

2.实现过程：

1.编写套接字

2.多线程的代码和任务类

3.文件描述符的处理方法的框架

4.读取请求

4.1.读取请求行

4.2.读取请求报头

4.3.分析请求行和报头

请求行的方法、URI、版本放到承装容器；

4.4.读取正文

5.构建响应

5.1.根据请求方法和是否带参来判断是否需要进行CGI处理：

5.2.把URI处理合理

6.CGI处理

7.发送响应

9.源码链接

1.需要实现的项目需求（web服务器的工作原理）

实现：从用户输入网页地址，到建立连接、获取和分析请求、对有参数的请求进行CGI机制处理（CGI机制：用户会访问web服务器的任意文件，服务器需要依靠参数对文件进行处理，不能把处理方法放在web服务器的代码下，因为用户只会访问它需要的，那么大量的处理方法是无意义的，而且内容太多了）、构建和发送响应的全过程；

下面是我画的一个实现全过程的思维导图

2.实现过程：

1.编写套接字

1. 使用单例模式类封装的一个套接字

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <pthread.h>
#include <cstdlib>
#include <cstring>
#include"Log.hpp"

#define Backlog 5
class TcpSocket
{
private:
    void Socket()
    {
        _socket = socket(AF_INET, SOCK_STREAM, 0);
        if (_socket < 0)
        {
            LOG(FATAL,"socket error");
            exit(1);
        }
        // 快速重启
        int opt = 1;
        setsockopt(_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    }
    void Bind()
    {
        struct sockaddr_in local;
        // 把套接字置为0；
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_addr.s_addr = INADDR_ANY;
        local.sin_port = htons(_port);
        if (bind(_socket, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            LOG(FATAL,"bind error");
            exit(2);
        }
    }
    void Listen()
    {
        if (listen(_socket, Backlog) < 0)
        {
            LOG(FATAL,"listen error");
            exit(3);
        }
    }

public:
    void Init()
    {
        Socket();
        Bind();
        Listen();
    }
    static TcpSocket *GetInstance(int port)
    {
        static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
        if (_sigleton == nullptr)
        {
            // 防止多进程访问临界资源
            pthread_mutex_lock(&lock);
            if (_sigleton == nullptr)
            {
                _sigleton = new TcpSocket(port);
                _sigleton->Init();
            }
            pthread_mutex_unlock(&lock);
        }
        return _sigleton;
    }
    int GetSocket()
    {
        return _socket;
    }
    ~TcpSocket()
    {
        if (_socket >= 0)
            close(_socket);
    }

private:
    TcpSocket(int port) : _socket(-1), _port(port)
    {
    }
    TcpSocket(const TcpSocket &s)
    {
    }

private:
    int _socket;
    int _port;
    // 单例模式指针
    static TcpSocket *_sigleton;
};
TcpSocket *TcpSocket::_sigleton = nullptr;

2.获取请求，添加到多线程，sigpipe信号必须忽略，客服端可能随时关闭，读端关闭，写端收到sigpipe中止进程；

#include "TcpSocket.hpp"
#include "Protocol.hpp"
#include "Thread_pool.hpp"
#include<signal.h>
class HttpSocket
{
private:
    int _port;
    int _quit;

public:
    HttpSocket(int port) : _port(port), _quit(false)
    {
    }
    void InitServer()
    {
        //信号SIGPIPE需要进行忽略，如果不忽略，在写入时候，可能直接崩溃server
        //客户端随时可能关闭连接，
        signal(SIGPIPE, SIG_IGN); 
    }
    void loop()
    {   
        TcpSocket *segleton = TcpSocket::GetInstance(_port);
        int listen_socket = segleton->GetSocket();
        LOG(INFO,"build success,wait client");
        while (!_quit)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int new_socket = accept(listen_socket, (struct sockaddr *)&peer, &len);
            if(new_socket<0)
                continue;
            ThreadPool::GetInstance()->Push(new_socket);
        }
    }
};

主函数

#include "HttpServer.hpp"
#include <cstdlib>
#include <memory>

void Usage()
{
    std::cout << "usage: ./main port" << std::endl;
}
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage();
        return 1;
    }
    HttpSocket s(atoi(argv[1]));
    s.InitServer();
    s.loop();
    return 0;
}

2.多线程的代码和任务类

线程池工作原理：一个生产消费模型的多线程线程池，accept成功后把sock文件描述符添加到线程池，由线程池构建一个Task类对象，Task类对象包含一个函数指针，这个指针指向对sock文件描述符的处理方法（读取请求报头、分析请求报头、构建响应报头等等）；

#pragma once
#include <iostream>
#include <queue>
#include <pthread.h>
#include "Log.hpp"
#include "Task.hpp"

#define NUM 5
class ThreadPool
{
private:
    void Lock()
    {
        pthread_mutex_lock(&_mt);
    }
    void Unlock()
    {
        pthread_mutex_unlock(&_mt);
    }
    void Wait()
    {
        pthread_cond_wait(&_cond, &_mt);
    }
    void Wakeup()
    {
        pthread_cond_signal(&_cond);
    }
    bool IfEmpty()
    {
        _q.empty();
    }
    void Pop(Task &t)
    {
        t = _q.front();
        _q.pop();
    }
    // 如果不是静态成员函数，那么参数实际有两个，一个是this指针
    static void *handler(void *arg)
    {
        Task t;
        pthread_detach(pthread_self());
        ThreadPool *tp = (ThreadPool *)arg;
        tp->Lock();
        while (tp->IfEmpty())
        {
            tp->Wait();
        }
        tp->Pop(t);
        tp->Unlock();
        t.ProcessOn();
    }

public:
    void Push(int sock)
    {
        Task ts(sock);
        _q.push(ts);
        Wakeup();
    }
    void InitThread()
    {
        pthread_t pt[_num];
        for (int i = 0; i < _num; i++)
        {
            if (pthread_create(&pt[i], nullptr, handler, this) != 0)
            {
                LOG(ERROR, "pthread_create fail");
                exit(1);
            }
        }
    }
    static ThreadPool *GetInstance()
    {
        static pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;
        if (_sigleton == nullptr)
        {
            pthread_mutex_lock(&_mutex);
            //双重判断，防止上面的判断成功线程被切换，调度回来时可能已经被其他线程new
            if(_sigleton == nullptr)
            {
                _sigleton = new ThreadPool;
                _sigleton->InitThread();
                LOG(INFO,"thread init ok");
            }
            pthread_mutex_lock;
        }
        return _sigleton;
    }

private:
    ThreadPool() : _num(NUM)
    {
        pthread_mutex_init(&_mt, nullptr);
        pthread_cond_init(&_cond, nullptr);
    }
    ThreadPool(const ThreadPool &tp) = delete;
    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mt);
        pthread_cond_destroy(&_cond);
    }

private:
    int _num;
    std::queue<Task> _q;
    pthread_mutex_t _mt;
    pthread_cond_t _cond;
    static ThreadPool *_sigleton;
};
ThreadPool *ThreadPool::_sigleton = nullptr;

任务类：成员：1.accept返回的套接字文件描述符；2.对这个描述符的处理方法（读取请求报头、分析请求报头、构建响应报头等等）；

#pragma once
#include <iostream>
#include "Protocol.hpp"
class Task
{
public:
    Task()
    {
    }
    Task(int sock) : _accept_sock(sock)
    {
    }
    ~Task()
    {
    }
    void ProcessOn()
    {
        _cb.ProcessOn(_accept_sock);
    }

private:
    int _accept_sock;
    Callback _cb;
};

3.文件描述符的处理方法的框架

框架：分别承装请求和响应报文的类，把它们当做结构体，用做读取的请求、构建的响应的存放；对sock文件描述符需要做读取和分析请求、构建和发送响应；

#pragma once
#include <iostream>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/sendfile.h>
#include <sys/wait.h>
#include <algorithm>
#include <sstream>
#include <vector>
#include <unordered_map>
#include "Util.hpp"
#include "Log.hpp"

#define WEB_ROOT "webroot"
#define PAGE_404 "webroot/page_404.html"
#define PAGE_400 "webroot/page_400.html"
#define PAGE_500 "webroot/page_500.html"
#define HOME_PAGE "index.html"
#define OK 202
#define CLIENT_ERR 400
#define SERVER_ERR 500
#define NOT_FOUND 404
#define END_LINE "\n"

// 做为承装请求报文的容器
class HttpRequest
{
public:
    std::string _request_line;
    std::vector<std::string> _request_header;
    std::string _blank;
    std::string _body;
};
// 做为承装构建响应报文的容器

class HttpResponse
{
public:
    std::string _status_line;
    std::vector<std::string> _status_header;
    std::string _blank;
    std::string _body;
};

class EndPoint
{
private:
    // 读取请求报头
    bool RecvRequestLine()
    {}
    bool RecvRequestHeader()
    {}
    // 分析请求报头
    void ParseRequestLine()
    {}
    bool RecvRequestBody()
    {}
private:
    void BuildStatusLine(int code)
    {}
public:
    // 读取
    void RecvRequest()
{}
    // 构建
    void BuildResponse()
    {}
    void SendResponse()
    {}
public:
    EndPoint(int sock) : _new_socket(sock), _stop(false)
    {}
    ~EndPoint()
    {
        if (_new_socket >= 0)
            close(_new_socket);
    }

private:
    HttpRequest _http_request;
    HttpResponse _http_response;

    int _new_socket;
    bool _stop;
};
class Callback
{
public:
    void ProcessOn(int new_socket)
    {
        EndPoint ep(new_socket);

        std::cout << "begin.........." << std::endl;
        ep.RecvRequest();
        if (ep.GetStop() == false)
        {
            ep.BuildResponse();
            ep.SendResponse();
        }

        std::cout << "end.........." << std::endl;

    }
};

4.读取请求

4.1.读取请求行

读取函数：不同的环境下，http协议的结尾的区分可能不同，可能为'\n'、'\r\n'、'\r',需要统一为'\n',方便后序处理；下面使用了一个小技巧：recv的MSG_PEEK选项：窥探读，读取下一个字节，但是不从内核缓冲区拿出来，所以后序可以继续读这个字节；

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <string>

class Util
{
public:
    static bool RecvLine(int sock, std::string &buffer)
    {
        char ch;
        while (ch != '\n')
        {
            ssize_t s = recv(sock, &ch, 1, 0);
            if (s > 0)
            {
                if (ch == '\r')
                {
                    // 窥探下一个元素但是不拿取;
                    recv(sock, &ch, 1, MSG_PEEK);
                    if (ch == '\n') // 处理\r\n->\n
                    {
                        recv(sock, &ch, 1, 0);
                    }
                    else // 处理\r->\n
                    {
                        ch = '\n';
                    }
                }
                buffer.push_back(ch);
            }
            else
            {
                return false;
            }
        }
        return true;
    }
};

读取请求报行，保存在承装类中，LOG是一个日志；

    // 读取请求行
    bool RecvRequestLine()
    {
        if (Util::RecvLine(_new_socket, _http_request._request_line))
        {
            // 去除\n
            _http_request._request_line.pop_back();
            LOG(INFO, _http_request._request_line);
            return true;
        }
        else
        {
            return false;
        }
    }