【Linux 网络】理解并应用应用层协议：HTTP（附简单HTTP服务器C++代码）

https://blog.csdn.net/huangyuchi/article/details/155441819

#pragma once
#include <iostream>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string>
#include <cstring>

// 实现网络地址与主机地址的转换

class InetAddr
{
public:
    InetAddr() {}

    // 网络转主机
    InetAddr(struct sockaddr_in &addr)
        : _addr(addr)
    {
        _prot = ntohs(_addr.sin_port); // 网络地址转主机地址
        char buff[1024];
        inet_ntop(AF_INET, &addr.sin_addr, buff, sizeof(buff)); // 将4字节网络风格的IP -> 点分十进制的字符串风格的IP
        _ip = std::string(buff);
    }

    // 主机转网络(客户端)
    InetAddr(std::string ip, uint16_t prot)
        : _ip(ip),
          _prot(prot)
    {
        memset(&_addr, 0, sizeof(_addr));
        _addr.sin_family = AF_INET;
        //&addr.sin_addr 是一个指向 struct in_addr 的指针，其内存地址等价于 &(addr.sin_addr.s_addr)（因为结构体的起始地址就是第一个成员的起始地址）
        inet_pton(AF_INET, _ip.c_str(), &_addr.sin_addr);
        _addr.sin_port = htons(_prot);
    }

    // 主机转网络(服务端)
    InetAddr(uint16_t prot)
        : _prot(prot)
    {
        memset(&_addr, 0, sizeof(_addr));
        _addr.sin_family = AF_INET;
        _addr.sin_port = htons(prot);
        _addr.sin_addr.s_addr = INADDR_ANY; // 任意ip地址
    }

    // 直接获取sockaddr_in
    struct sockaddr *Getaddr()
    {
        return (struct sockaddr *)&_addr;
    }

    socklen_t Len()
    {
        socklen_t len = sizeof(_addr);
        return len;
    }

    uint16_t prot()
    {
        return _prot;
    }

    std::string ip()
    {
        return _ip;
    }

    // 运算符重载
    bool operator==(InetAddr &addr)
    {
        return _prot == addr._prot && _ip == addr._ip;
    }

    std::string Getname()
    {
        return _ip + ':' + std::to_string(_prot);
    }

private:
    struct sockaddr_in _addr;
    uint16_t _prot;
    std::string _ip;
};

// 实现日志模块

#pragma once
#include <iostream>
#include <sstream>    // 包含stringstream类
#include <filesystem> //C++17文件操作接口库
#include <fstream>
#include <sys/types.h>
#include <unistd.h>
#include "Mutex.hpp"
using namespace std;
using namespace MutexModule;

// 补充：外部类只能通过内部类的实例化对象，来访问内部类中的方法与成员，且受修饰符限制
//       内部类可以直接访问外部类的方法以及成员，没有限制

namespace LogModule
{
    const string end = "\r\n";

    // 实现刷新策略：a.向显示器刷新 b.向指定文件刷新

    // 利用多态机制实现
    // 包含至少一个纯虚函数的类称为抽象类，不能实例化，只能被继承
    class LogStrategy // 基类
    {
    public:
        //"=0"声明为纯虚函数。纯虚函数强制派生类必须重写该函数
        virtual void SyncLog(const string &message) = 0;
    };

    // 向显示器刷新：子类
    class ConsoleLogStrategy : public LogStrategy
    {
    public:
        void SyncLog(const string &message) override
        {
            // 加锁，访问显示器，显示器也是临界资源
            LockGuard lockguard(_mutex);
            cout << message << end;
        }

    private:
        Mutex _mutex;
    };

    // 向指定文件刷新：子类
    const string defaultpath = "./log";
    const string defaultfile = "my.log";
    class FileLogStrategy : public LogStrategy
    {
    public:
        FileLogStrategy(const string &path = defaultpath, const string &file = defaultfile)
            : _path(path), _file(file)
        {
            LockGuard lockguard(_mutex);
            // 判断路径是否存在,如果不存在就创建对应的路径
            if (!(filesystem::exists(_path)))
                filesystem::create_directories(_path);
        }

        void SyncLog(const string &message) override
        {
            // 合成最后路径
            string Path = _path + (_path.back() == '/' ? "" : "/") + _file;
            // 打开文件
            ofstream out(Path, ios::app);
            out << message << end;
        }

    private:
        string _path;
        string _file;
        Mutex _mutex;
    };

    //

    // 日志等级
    // enum class：强类型枚举。1.必须通过域名访问枚举值 2.枚举值不能隐式类型转化为整型
    enum class LogLevel
    {
        DEBUG,   // 调试级
        INFO,    // 信息级
        WARNING, // 警告级
        ERROR,   // 错误级
        FATAL    // 致命级
    };

    //

    // 将等级转化为字符串
    string LevelToStr(LogLevel level)
    {
        switch (level)
        {
        case LogLevel::DEBUG:
            return "DEBUG";
        case LogLevel::INFO:
            return "DEBUG";
        case LogLevel::WARNING:
            return "WARNING";
        case LogLevel::ERROR:
            return "ERROR";
        case LogLevel::FATAL:
            return "FATAL";
        default:
            return "UNKOWN";
        }
    }

    // 获取时间
    string GetTime()
    {
        // time函数：获取当前系统的时间戳
        // localtime_r函数：将时间戳转化为本地时间（可重入函数，localtime则是不可重入函数）
        // struct tm结构体，会将转化之后的本地时间存储在结构体中
        time_t curr = time(nullptr);
        struct tm curr_time;
        localtime_r(&curr, &curr_time);
        char buffer[128];
        snprintf(buffer, sizeof(buffer), "%04d-%02d-%02d %02d:%02d:%02d",
                 curr_time.tm_year + 1900, // 年份是从1900开始计算的，需要加上1900才能得到正确的年份
                 curr_time.tm_mon + 1,     // 月份了0~11，需要加上1才能得到正确的月份
                 curr_time.tm_mday,        // 日
                 curr_time.tm_hour,        // 时
                 curr_time.tm_min,         // 分
                 curr_time.tm_sec);        // 秒

        return buffer;
    }

    //

    // 实现日志信息，并选择刷新策略
    class Logger
    {
    public:
        Logger()
        {
            // 默认选择显示器刷新
            Strategy = make_unique<ConsoleLogStrategy>();
        }

        void EnableConsoleLogStrategy()
        {
            Strategy = make_unique<ConsoleLogStrategy>();
        }

        void EnableFileLogStrategy()
        {
            Strategy = make_unique<FileLogStrategy>();
        }

        // 日志信息
        class LogMessage
        {
        public:
            LogMessage(const LogLevel &level, const string &name, const int &line, Logger &logger)
                : _level(level),
                  _name(name),
                  _logger(logger),
                  _line_member(line)
            {
                _pid = getpid();
                _time = GetTime();
                // 合并：日志信息的左半部分

                stringstream ss; // 创建输出流对象,stringstream可以将输入的所有数据全部转为为字符串
                ss << "[" << _time << "] "
                   << "[" << LevelToStr(_level) << "] "
                   << "[" << _pid << "] "
                   << "[" << _name << "] "
                   << "[" << _line_member << "] "
                   << " - ";

                // 返回ss中的字符串
                _loginfo = ss.str();
            }

            // 日志文件的右半部分:可变参数，重载运算符<<

            // e.g. <<"huang"<<123<<"dasd"<<24
            template <class T>
            LogMessage &operator<<(const T &message) // 引用返回可以让后续内容不断追加
            {
                stringstream ss;
                ss << message;
                _loginfo += ss.str();

                // 返回对象！
                return *this;
            }

            // 销毁时，将信息刷新
            ~LogMessage()
            {
                // 日志文件
                _logger.Strategy->SyncLog(_loginfo);
            }

        private:
            string _time;
            LogLevel _level;
            pid_t _pid;
            string _name;
            int _line_member;
            string _loginfo; // 合并之后的一条完整信息

            // 日志对象
            Logger &_logger;
        };

        // 重载运算符(),便于创建LogMessage对象
        // 这里返回临时对象：当临时对象销毁时，调用对应的析构函数，自动对象中创建好的日志信息进行刷新！
        // 其次局部对象也不能传引用返回！
        LogMessage operator()(const LogLevel &level, const string &name, const int &line)
        {
            return LogMessage(level, name, line, *this);
        }

    private:
        unique_ptr<LogStrategy> Strategy;
    };

    // 为了用户使用更方便，我们使用宏封装一下
    Logger logger;

// 切换刷新策略
#define Enable_Console_LogStrategy() logger.EnableConsoleLogStrategy();
#define Enable_File_LogStrategy() logger.EnableFileLogStrategy();
// 创建日志，并刷新
//__FILE__ 和 __LINE__ 是编译器预定义的宏，作用是获取当前代码所在的文件名、行号
#define LOG(level) logger(level, __FILE__, __LINE__) // 细节：不加；
};

#pragma once

// 禁止拷贝类
class NoCopy
{
public:
    NoCopy() {};
    // 拷贝构造
    NoCopy(const NoCopy &nocopy) = delete;
    // 赋值重载
    const NoCopy &operator=(const NoCopy &nocopy) = delete;
};

enum EXIT
{
    OK = 0,
    SOCK_ERR,
    BIND_ERR,
    LISTEN_ERR,
    ACCP_ERR,
    TCPSERVER_ERR,
    TCPCLIENT_ERR,
    CONN_ERR
};

// 封装锁接口
#pragma once
#include <pthread.h>

namespace MutexModule
{
    class Mutex
    {
    public:
        Mutex()
        {
            pthread_mutex_init(&mutex, nullptr);
        }

        ~Mutex()
        {
            pthread_mutex_destroy(&mutex);
        }

        void Lock()
        {
            pthread_mutex_lock(&mutex);
        }

        void Unlock()
        {
            pthread_mutex_unlock(&mutex);
        }

        pthread_mutex_t *Get()
        {
            return &mutex;
        }

    private:
        pthread_mutex_t mutex;
    };

    class LockGuard
    {
    public:
        LockGuard(Mutex &mutex)
            : _Mutex(mutex)
        {
            _Mutex.Lock();
        }

        ~LockGuard()
        {
            _Mutex.Unlock();
        }

    private:
        // 为了保证锁的底层逻辑，锁是不能够拷贝的，并且也是没有拷贝构造函数的
        //  避免拷贝，应该引用
        Mutex &_Mutex;
    };
}

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <memory>
#include "InetAddr.hpp"
#include "Log.hpp"
#include "Comment.hpp"
using namespace LogModule;

const int BACK = 16;

namespace SocketModule
{
    // 模板方法模式
    // 基类大部分函数都是虚函数
    class Socket
    {
    public:
        virtual void SocketOrDie() = 0;
        virtual void BindOrDie(uint16_t prot) = 0;
        virtual void ListenOrDie(int backlog) = 0;
        virtual std::shared_ptr<Socket> Accept(InetAddr *client) = 0;
        virtual void ConnectOrDie(InetAddr &addr) = 0;
        virtual ssize_t Recv(string &buffer) = 0;
        virtual int Send(const std::string &message) = 0;
        virtual void Close() = 0;

        void BuildTcpSocket(uint16_t prot, int backlog = BACK)
        {
            SocketOrDie();
            BindOrDie(prot);
            ListenOrDie(backlog);
        }
    };

    class TcpSocket : public Socket
    {
    public:
        TcpSocket() {}

        TcpSocket(int fd)
            : _sockfd(fd)
        {
        }

        void SocketOrDie() override
        {
            _sockfd = socket(AF_INET, SOCK_STREAM, 0);
            if (_sockfd < 0)
            {
                LOG(LogLevel::ERROR) << "socket error";
                exit(SOCK_ERR);
            }
        }

        void BindOrDie(uint16_t prot) override
        {
            InetAddr addr(prot);
            int ret = bind(_sockfd, addr.Getaddr(), addr.Len());
            if (ret < 0)
            {
                LOG(LogLevel::ERROR) << "bind error";
                exit(BIND_ERR);
            }
        }

        void ListenOrDie(int backlog) override
        {
            int ret = listen(_sockfd, backlog);
            if (ret < 0)
            {
                LOG(LogLevel::ERROR) << "listen error";
                exit(LISTEN_ERR);
            }
        }

        // 客户端
        std::shared_ptr<Socket> Accept(InetAddr *client) override
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int fd = accept(_sockfd, (struct sockaddr *)&peer, &len);
            if (fd < 0)
            {
                LOG(LogLevel::ERROR) << "accept error";
                exit(ACCP_ERR);
            }

            // 将客户端信息带出
            InetAddr addr(peer);
            client = &addr;
            // accept成功后返回一个新的套接字，用于服务
            // 可以直接返回fd，也可以返回新对象(的指针)
            return std::make_shared<TcpSocket>(fd);
        }

        void ConnectOrDie(InetAddr &addr) override
        {
            int ret = connect(_sockfd, addr.Getaddr(), addr.Len());
            if (ret < 0)
            {
                LOG(LogLevel::ERROR) << "connect error";
                exit(CONN_ERR);
            }
        }

        ssize_t Recv(string &buffer) override
        {
            char str[4096 * 3];
            ssize_t n = recv(_sockfd, str, sizeof(str), 0);
            if (n)
            {
                // 首先，str并不是空白的，其空间可以被其他函数使用过，保存有垃圾数据
                // 其次，revc函数读取后，并不会主动的为我们读取到的信息末尾加上'\0'
                // 所以，我们必须自己显示的加上！
                // 不然当buffer+=的时候，str作为C风格的字符串，遇到'\0'才会停止
                // 导致程序就会不知道读到哪停，把后面的内存垃圾也一并收进去了！
                // 最终导致json串解析的时候失败！

                str[n] = 0;
                buffer += str; // 一定是+=，缓冲区信息是累加，而不是覆盖
            }
            return n;
        }

        int Send(const std::string &message) override
        {
            return send(_sockfd, message.c_str(), message.size(), 0);
        }

        void Close() override
        {
            close(_sockfd);
        }

        int Sockfd()
        {
            return _sockfd;
        }

    private:
        int _sockfd;
    };
}

#pragma once
#include <sys/types.h>
#include <sys/wait.h>
#include <functional>
#include "Socket.hpp"
using namespace SocketModule;

class TcpServer
{
    using Func_t = function<void(shared_ptr<Socket>, InetAddr &)>;

public:
    TcpServer(uint16_t prot)
        : _prot(prot),
          _isrunning(false)
    {
        // 完成tcp套接字的创建、绑定、监听
        ts.BuildTcpSocket(_prot);
    }

    void Start(Func_t func)
    {
        _func = func;
        _isrunning = true;
        while (_isrunning)
        {
            auto sock = ts.Accept(&_client);
            if (sock == nullptr)
                continue;

            pid_t pid = fork();
            if (pid == 0)
            {
                // 关闭不需要的描述符
                ts.Close();
                // 子进程
                if (fork() > 0)
                    return;

                // 孙子进程执行任务
                _func(sock, _client);
                return;
            }
            else if (pid > 0)
            {
                // 父进程
                // 关闭不需要的描述符
                sock->Close();
                // 子进程会立刻退出，不会阻塞等待
                wait(&pid);
            }
            else
            {
                ts.Close();
                LOG(LogLevel::ERROR) << "fork error";
                return;
            }
        }
        _isrunning = false;
    }

private:
    uint16_t _prot;
    TcpSocket ts;
    bool _isrunning;

    InetAddr _client;
    Func_t _func;
};

#pragma once
#include "TcpServer.hpp"
#include <memory>
#include "Tool.hpp"

const string space = " ";
const std::string linesep = ": ";

const string webroot = "./wwwroot";
const string homepage = "index.html";

class HttpRequest
{
public:
    // 不重要，请求的序列化由客户端实现：浏览器！
    std::string Serialize()
    {
        return std::string();
    }

    // 实现，将客户端发送过来的http字符串，反序列化，得到url
    bool Deserialize(std::string &reqstr)
    {
        // 1.获取请求行
        string req = Tool::ReadOneLine(reqstr);
        // 2.将请求行序列化
        ParseReqLine(req);
        // 3.合成正确的uri路径
        if (_uri == "/")
            _uri = webroot + _uri + homepage;
        else
            _uri = webroot + _uri;

        // bebug
        cout << "_method: " << _method << endl;
        cout << "_uri: " << _uri << endl;
        cout << "_version: " << _version << endl;

        return true;
    }

    // 将请求行按照空格分隔
    void ParseReqLine(std::string &reqline)
    {
        // GET / HTTP/1.1
        std::stringstream ss(reqline);
        ss >> _method >> _uri >> _version;
    }

    string Uri()
    {
        return _uri;
    }

private:
    std::string _method;
    std::string _uri;
    std::string _version;
};

class HttpResponse
{
public:
    HttpResponse()
        : _version("HTTP/1.1")
    {
    }

    // 不重要，应答的反序列化由客户端实现：浏览器！
    bool Deserialize(std::string &reqstr)
    {
        return true;
    }

    // 实现，将对应的资料序列化后，返回给客户端
    std::string Serialize()
    {
        std::string status_line = _version + space + std::to_string(_code) + space + _desc + Separator;
        std::string resp_header;
        for (auto &str : _headers)
        {
            resp_header += str.first + linesep + str.second + Separator;
        }

        return status_line + resp_header + _blankline + _text;
    }

    // 获取资源，添加报头
    void MakeResponse(string uri)
    {
        // 顺便设置状态行信息
        if (Tool::ReadFileContent(uri, _text))
        {
            // 获取资源成功
            SetCode(200);
        }
        else
        {
            // 获取资源失败
            SetCode(404);
            uri = "./wwwroot/404.html";
            Tool::ReadFileContent(uri, _text);
        }

        // 添加报头

        // 正文长度
        string filesize = to_string(Tool::FileSize(uri)); // 当以二进制方式读取时，不会存在'\n'没有被读取的情况。

        // string filesize = to_string(_text.size()); // 以字符串方式读取，会少读取一部分'\n'，与FileSize()的返回值不一致
        _headers.insert(make_pair("Content-Length", filesize));
        // 正文类型
        string Suffic = Tool::Uri2Suffix(uri);
        _headers.insert(make_pair("Content-Type", Suffic));
    }

    void SetCode(int code)
    {
        // 设置状态码
        _code = code;
        switch (code)
        {
        case 200:
            _desc = "OK";
            break;
        case 404:
            _desc = "NOT FOUND";
            break;
        default:
            break;
        }
    }

    string text()
    {
        return _text;
    }

public:
    std::string _version;
    int _code;                                        // 404
    std::string _desc;                                // "Not Found"
    string _text;                                     // 资源
    unordered_map<std::string, std::string> _headers; // 报头

    string _blankline = "\r\n";
};

class HTTP
{
public:
    HTTP(uint16_t prot)
        : _tsp(make_unique<TcpServer>(prot))
    {
    }

    void HandlerHttpRquest(std::shared_ptr<Socket> &sock, InetAddr &client)
    {
        // 接收浏览器发送来的http请求字符串
        string str;
        sock->Recv(str);

        // 反序列化：http字符串
        HttpRequest req;
        req.Deserialize(str);

        // 序列化：将客户端要访问的资源返回
        HttpResponse rep;
        rep.MakeResponse(req.Uri());
        string ret = rep.Serialize();
        sock->Send(ret);
    }

    void Run()
    {
        _tsp->Start([this](std::shared_ptr<Socket> sock, InetAddr &client)
                    { this->HandlerHttpRquest(sock, client); });
    }

private:
    unique_ptr<TcpServer> _tsp;
};

#pragma once

// 工具类
#include <string>
#include <fstream>

const string Separator = "\r\n";

struct Tool
{
    // 将资源写入 text
    static bool ReadFileContent(std::string uri, std::string &text)
    {
        // version1：以字符串方式读取
        //  std::fstream in(uri);
        //  if (in.is_open())
        //  {
        //      std::string str;
        //      // getline 会自动去掉每一行的换行符 (\n)
        //      // 这会导致最终发送的信息的数量会少一点
        //      while (getline(in, str))
        //      {
        //          text += str;
        //      }
        //      in.close();
        //      return true;
        //  }
        //  return false;

        // version2：以二进制方式读取，更好！
        // 更兼容照片、视频等资源
        std::ifstream in(uri, std::ios::binary); // 以二进制模式打开文件
        int filesize = FileSize(uri);
        if (filesize < 0)
            return false;
        if (in.is_open())
        {
            text.resize(filesize);
            in.read(&text[0], filesize);
            return true;
        }

        return false;
    }

    // 获取请求行
    static string ReadOneLine(string &reqstr)
    {
        int pos = reqstr.find(Separator);
        string ret = reqstr.substr(0, pos);
        reqstr.erase(0, pos + Separator.size());
        return ret;
    }

    // 获取文件大小
    // 该读取方式是不会忽略掉'\n'的
    // 当ReadFileContent使用字符串发的方式读取时，其读取上来的大小会与下面得到的大小不一致，导致网页无法加载！
    static int FileSize(string filename)
    {
        std::ifstream in(filename, std::ios::binary); // 以二进制模式打开文件
        if (!in.is_open())
            return -1;
        in.seekg(0, in.end);       // 将读取指针直接跳转到文件的最末端
        int filesize = in.tellg(); // 获取当前读取指针的位置,既变相的获取文件大小
        in.close();

        return filesize;
    }

    // 获取资源后缀,返回对应类型
    static std::string Uri2Suffix(const std::string &targetfile)
    {
        // ./wwwroot/indext.html
        auto pos = targetfile.find('.');
        if (pos == string::npos)
        {
            return "text/html";
        }

        string ret = targetfile.substr(pos);
        if (ret == ".html" || ret == ".htm")
        {
            return "text/html";
        }
        else if (ret == ".png")
        {
            return "image/png";
        }
        else if (ret == ".jpg")
        {
            return "image/jpg";
        }
        else if (ret == ".mp4")
        {
            return "video/mp4";
        }
        else
        {
            return "";
        }
    }
};

#include "HTTP.hpp"

int main(int args, char *argv[])
{
    if (args != 2)
    {
        cout << "Please use: " << argv[0] << " prot";
        return 0;
    }

    int prot = stoi(argv[1]);
    unique_ptr<HTTP> up = make_unique<HTTP>(prot);
    up->Run();
}