linux网络之Http协议用法及说明

#pragma once
#include "Common.hpp"
// 网络地址和主机地址之间进行转换的类

class InetAddr
{
public:
    InetAddr() {}
    InetAddr(struct sockaddr_in &addr)
    {
        SetAddr(addr);
    }
    InetAddr(const std::string &ip, uint16_t port) : _ip(ip), _port(port)
    {
        // 主机转网络
        memset(&_addr, 0, sizeof(_addr));
        _addr.sin_family = AF_INET;
        inet_pton(AF_INET, _ip.c_str(), &_addr.sin_addr);
        _addr.sin_port = htons(_port);
        // local.sin_addr.s_addr = inet_addr(_ip.c_str()); // TODO
    }
    InetAddr(uint16_t port) : _port(port), _ip()
    {
        // 主机转网络
        memset(&_addr, 0, sizeof(_addr));
        _addr.sin_family = AF_INET;
        _addr.sin_addr.s_addr = INADDR_ANY;
        _addr.sin_port = htons(_port);
    }
    void SetAddr(struct sockaddr_in &addr)
    {
        _addr = addr;
        // 网络转主机
        _port = ntohs(_addr.sin_port); // 从网络中拿到的！网络序列
        // _ip = inet_ntoa(_addr.sin_addr); // 4字节网络风格的IP -> 点分十进制的字符串风格的IP
        char ipbuffer[64];
        inet_ntop(AF_INET, &_addr.sin_addr, ipbuffer, sizeof(_addr));
        _ip = ipbuffer;
    }
    uint16_t Port() { return _port; }
    std::string Ip() { return _ip; }
    const struct sockaddr_in &NetAddr() { return _addr; }
    const struct sockaddr *NetAddrPtr()
    {
        return CONV(_addr);
    }
    socklen_t NetAddrLen()
    {
        return sizeof(_addr);
    }
    bool operator==(const InetAddr &addr)
    {
        return addr._ip == _ip && addr._port == _port;
    }
    std::string StringAddr()
    {
        return _ip + ":" + std::to_string(_port);
    }
    ~InetAddr()
    {
    }

private:
    struct sockaddr_in _addr;
    std::string _ip;
    uint16_t _port;

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

using namespace LogModule;

static const int gbacklog = 16;

// 基类
namespace SocketModule
{
    class Socket
    {
    public:
        virtual ~Socket() {}
        virtual void Sockfd() = 0;            // 创建套接字
        virtual void Bind(uint16_t port) = 0; // 绑定需要端口号
        virtual void Listen(int backlog) = 0;
        virtual std::shared_ptr<Socket> Accept(InetAddr *client) = 0;
        virtual void Close() = 0;
        virtual int Recv(std::string *out)=0;
        virtual int Send(const std::string &message)=0;
        virtual int Connect(const std::string &server_ip, uint16_t port)=0;
    public:
        void BuildTcpSocket(uint16_t port)
        {
            Sockfd();
            Bind(port);
            Listen(gbacklog);
        }
    };

    static const int defaultfd = -1;
    class TcpSocket : public Socket
    {
    public:
        TcpSocket() : _sockfd(defaultfd) {}
        TcpSocket(int fd) : _sockfd(fd) {}
        ~TcpSocket() {}
        void Sockfd() override
        {
            _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
            if (_sockfd < 0)
            {
                LOG(LogLevel::FATAL) << "socket error";
                exit(SOCK_ERR);
            }
            LOG(LogLevel::INFO) << "socket success";
        }
        void Bind(uint16_t port) override
        {
            InetAddr peer(port);
            int n = bind(_sockfd, peer.NetAddrPtr(), peer.NetAddrLen()); // 绑定对象
            if (n < 0)
            {
                LOG(LogLevel::FATAL) << "bind error";
                exit(BIND_ERR);
            }
            LOG(LogLevel::INFO) << "bind success";
        }
        void Listen(int backlog) override
        {
            // 监听，继续用_sockfd即可
            int n = listen(_sockfd, backlog);
            if (n < 0)
            {
                LOG(LogLevel::FATAL) << "listen error";
                exit(LISTEN_ERR);
            }
            LOG(LogLevel::INFO) << "listen success";
        }
        // unique_ptr：独占所有权，只能有一个指针持有资源，不能拷贝，只能移动。
        // shared_ptr`：共享所有权，引用计数，可以拷贝、复制，多个智能指针同时管理同一个对象；计数到 0 自动释放。
        std::shared_ptr<Socket> Accept(InetAddr *client) override
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int fd = accept(_sockfd, CONV(peer), &len); // 接收对象
            if (fd < 0)
            {
                LOG(LogLevel::WARNING) << "accept error";
                return nullptr;
            }
            // 接收成功
            LOG(LogLevel::DEBUG) << "accept success："<<client->StringAddr();
            client->SetAddr(peer);                  // 用peer把客户端的信息带出来
            return std::make_shared<TcpSocket>(fd); // 返回一个TcpSocket的对象
        }
        void Close() override
        {
            if (_sockfd >= 0)
            {
                ::close(_sockfd);
            }
        }
        int Recv(std::string *out)override
        {
            //缓冲区
            char buffer[4096];
            int n=recv(_sockfd,buffer,sizeof(buffer)-1,0);
            if(n>0)
            {
               buffer[n]=0;
               *out+=buffer;
            }
            return n;
        }
        int Send(const std::string &message)override
        {
            return send(_sockfd,message.c_str(),message.size(),0);
        }
        //因为是客户端一定要绑定服务端的ip地址和port，告诉内核我要连哪一个机器上的哪个程序
        int Connect(const std::string &server_ip, uint16_t port) override
        {
            InetAddr server(server_ip, port);
            return ::connect(_sockfd, server.NetAddrPtr(), server.NetAddrLen());
        }
    private:
        int _sockfd;
    };
}

#include "Socket.hpp"
#include <iostream>
#include <memory>
#include <sys/wait.h>
#include <functional>

using namespace SocketModule;
using namespace LogModule;

using ioservice=std::function<void(std::shared_ptr<Socket> sock,InetAddr&client)>;
class TcpServer
{
public:
    TcpServer(uint16_t port,ioservice service):_port(port),_isrunning(false),_listenptr(std::make_unique<TcpSocket>()),_service(service)
    {
        _listenptr->BuildTcpSocket(_port);
    }
    void Start()
    {
       _isrunning=true;
       while(_isrunning)
       {
            //开始接听
            InetAddr client(_port);
            auto sock=_listenptr->Accept(&client);//这种接收方式客户端信息我们也有了
            if(sock==nullptr)
            {
                continue;
            }
            //创建子进程干活
            pid_t id=fork();
            if(id<0)
            {
                LOG(LogLevel::ERROR)<<"fork error";
                exit(FORK_ERR);
            }
            else if(id==0)
            {
                //子进程干的活是服务，压根不需要监听，所以我们得把监听的_fd给关闭
                _listenptr->Close();
                if(fork()>0)
                {
                    exit(OK);
                }
                //留下孙子进程执行任务
                _service(sock,client);
                exit(OK);
            }
            else
            {
                //先关闭
                sock->Close();
                //再等待
                pid_t pid=waitpid(id,nullptr,0);
                (void)pid;
            }
       }
       _isrunning=false;
    }
     ~TcpServer(){}
private:
    uint16_t _port;
    std::unique_ptr<TcpSocket> _listenptr;
    bool _isrunning;
    ioservice _service;
};

#pragma once 

#include <iostream>
#include <fstream>
#include <string>

// 工具类

class Util
{
public:
    static bool ReadFileContent(const std::string &filename , std::string *out)
    {
        // version1: 默认是以文本方式读取文件的. 图片是二进制的.
        // std::ifstream in(filename);
        // if (!in.is_open())
        // {
        //     return false;
        // }
        // std::string line;
        // while(std::getline(in, line))
        // {
        //     *out += line;
        // }
        // in.close();

        // version2 : 以二进制方式进行读取
        int filesize = FileSize(filename);
        if(filesize > 0)
        {
            std::ifstream in(filename);
            if(!in.is_open())
                return false;
            out->resize(filesize);
            in.read((char*)(out->c_str()), filesize);
            in.close();
        }
        else
        {
            return false;
        }

        return true;
    }
    static bool ReadOneLine(std::string &bigstr, std::string *out, const std::string &sep/*\r\n*/)
    {
        auto pos = bigstr.find(sep);
        if(pos == std::string::npos)
            return false;
        *out = bigstr.substr(0, pos);
        bigstr.erase(0, pos + sep.size());
        return true;
    }
    static int FileSize(const std::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.seekg(0, in.beg);
        in.close();
        return filesize;
    }
};

#pragma once
#include "Socket.hpp"
#include "TcpServer.hpp"
#include "Util.hpp"
#include "Log.hpp"
#include <iostream>
#include <string>
#include <memory>
#include <sstream>
#include <unordered_map>
using namespace SocketModule;
using namespace LogModule;
const std::string gspace = " ";
const std::string glinespace = "\r\n";
const std::string glinesep = ": ";
const std::string webroot = "./wwwroot";   // 根目录的路径
const std::string homepage = "index.html"; // 首页
const std::string page_404 = "/404.html";  // 错误页面

class HttpRequest
{
public:
     HttpRequest()
     {
     }
     std::string Serialize()
     {
          return std::string();
     }
     // 分割请求行
     bool Praseline(std::string &reqline)
     {
          std::stringstream ss(reqline);
          ss >> _method >> _uri >> _version;
     }
     // 反序列化
     bool DeSerialize(std::string &reqstr)
     {
          // 获取请求行
          std::string reqline;
          bool res = Util::ReadOneLine(reqstr, &reqline, glinespace);
          if (!res)
          {
               return false;
          }
          LOG(LogLevel::DEBUG) << reqline;
          // 开始分割
          Praseline(reqline);
          if (_uri == "/")
          {
               _uri = webroot + _uri + homepage;
          }
          else
          {
               _uri = webroot + _uri;
          }
          LOG(LogLevel::DEBUG) << "_method: " << _method;
          LOG(LogLevel::DEBUG) << "_uri: " << _uri;
          LOG(LogLevel::DEBUG) << "_version: " << _version;
          // ./wwwroot/XXX.YYY
          return true;
     }
     std::string Uri() { return _uri; }
     ~HttpRequest()
     {
     }

private:
     std::string _method;  // 请求方法
     std::string _uri;     // 资源
     std::string _version; // 版本
     std::unordered_map<std::string, std::string> _headers;
     std::string blackline;
     std::string _text;
};

class HttpResponse
{
public:
     HttpResponse() : blackline(glinespace), _version("HTTP/1.0")
     {
     }
     // 序列化
     std::string Serialize()
     {
          // 拼接成字符串
          std::string repline = _version + gspace + std::to_string(_code) + gspace + _desc + glinespace;
          // 拼接响应报头
          std::string repkv;
          for (auto &header : _headers)
          {
               std::string line = header.first + glinesep + header.second + glinespace;
               repkv += line;
          }
          return repline + repkv + blackline + _text;
     }
     // 设置要打开的本地资源文件路径，例如 `./wwwroot/index.html`。
     void SetTargetFile(const std::string &target)
     {
          _targetfile = target;
     }
     // 设置退出码
     void Setcode(int code)
     {
          _code = code;
          switch (_code)
          {
          case 200:
               _desc = "OK";
               break;
          case 404:
               _desc = "Not Found";
               break;
          default:
               break;
          }
     }
     // 设置请求报头
     void SetHeader(const std::string &key, const std::string &value)
     {
          auto iter = _headers.find(key);
          if (iter != _headers.end())
               return;
          _headers.insert(std::make_pair(key, value));
     }
     std::string Uri2Suffix(const std::string &targetfile)
     {
          // 现在开始截取后缀
          auto pos = targetfile.rfind(".");
          if (pos == std::string::npos)
          {
               return "text/html";
          }
          std::string suffix = targetfile.substr(pos); // 从pos接到最后
          if (suffix == ".html" || suffix == ".htm")
               return "text/html";
          else if (suffix == ".jpg")
               return "image/jpeg";
          else if (suffix == "jpg")
               return "image/jpg";
          else
               return "";
     }
     bool MakeResponse()
     {
          if (_targetfile == "./wwwroot/favicon.ico")
          {
               LOG(LogLevel::DEBUG) << "用户请求: " << _targetfile << "忽略它";
               return false;
          }
          int filesize = 0;
          bool res = Util::ReadFileContent(_targetfile, &_text); // 浏览器请求的资源，一定会存在吗？出错呢？
          if(!res)
          {
               //走404页面,首先清空文本
               _text="";
               LOG(LogLevel::WARNING) << "client want get : " << _targetfile << " but not found";
               Setcode(404);
               _targetfile=webroot+page_404;//重新给_targetfile
               filesize=Util::FileSize(_targetfile);
               Util::ReadFileContent(_targetfile,&_text);
               std::string suffix=Uri2Suffix(_targetfile);
               //重读
               SetHeader("Content-type",suffix);
               SetHeader("Content-length",std::to_string(filesize));
          }
          else
          {
               //读取_text
               LOG(LogLevel::DEBUG)<<"read success："<<_targetfile;
               Setcode(200);
               filesize=Util::FileSize(_targetfile);
               std::string suffix=Uri2Suffix(_targetfile);
               SetHeader("Content-length",std::to_string(filesize));
               SetHeader("Content-type",suffix);
          }
          return true;
     }
     bool Deserialize(std::string &reqstr)
     {
          return true;
     }
     ~HttpResponse() {}

private:
     std::string _version; // HTTP版本默认 "HTTP/1.0"
     int _code;
     std::string _desc;
     std::unordered_map<std::string, std::string> _headers;
     std::string blackline;
     std::string _text;       // 响应body，读取的html/图片文件内容
                              // 其他属性
     std::string _targetfile; // 要读取的本地磁盘文件路径 ./wwwroot/xxx.html
};

class Http
{
public:
    Http(uint16_t port) : tsvrp(std::make_unique<TcpServer>(port))
    {
    }
    void HandlerHttpRquest(std::shared_ptr<Socket> &sock, InetAddr &client)
    {
        // 收到请求
        std::string httpreqstr;
        // 假设：概率大，读到了完整的请求
        // bug!
        int n = sock->Recv(&httpreqstr); // 浏览器给我发过来的是一个大的http字符串, 其实我们的recv也是有问题的。tcp是面向字节流的.
        if (n > 0)
        {
            std::cout << "##########################" << std::endl;
            std::cout << httpreqstr;
            std::cout << "##########################" << std::endl;
            // 对报文完整性进行审核 -- 缺
            // 所以，今天，我们就不在担心，用户访问一个服务器上不存在的资源了.
            // 我们更加不担心，给用户返回任何网页资源(html, css, js, 图片，视频)..., 这种资源，静态资源！！
            HttpRequest req;
            req.DeSerialize(httpreqstr);
            HttpResponse resp;
            resp.SetTargetFile(req.Uri());
            if (resp.MakeResponse())
            {
                std::string response_str = resp.Serialize();
                sock->Send(response_str);
            }
            // HttpResponse resp;
            // resp._version = "HTTP/1.1";
            // resp._code = 200; // success
            // resp._desc = "OK";
            // //./wwwroot/a/b/c.html
            // LOG(LogLevel::DEBUG) << "用户请求: " << filename;
            // bool res = Util::ReadFileContent(filename, &(resp._text)); // 浏览器请求的资源，一定会存在吗？出错呢？
            // (void)res;
        }

// #ifndef DEBUG
// #define DEBUG
#ifdef DEBUG
        // 收到请求
        std::string httpreqstr;
        // 假设：概率大，读到了完整的请求
        sock->Recv(&httpreqstr); // 浏览器给我发过来的是一个大的http字符串, 其实我们的recv也是有问题的。tcp是面向字节流的.
        std::cout << httpreqstr;

        // 直接构建http应答. 内存级别+固定
        HttpResponse resp;
        resp._version = "HTTP/1.1";
        resp._code = 200; // success
        resp._desc = "OK";

        std::string filename = webroot + homepage; // "./wwwroot/index.html";
        bool res = Util::ReadFileContent(filename, &(resp._text));
        (void)res;
        std::string response_str = resp.Serialize();
        sock->Send(response_str);
#endif
        // 对请求字符串，进行反序列化
    }
    void Start()
    {
        tsvrp->Start([this](std::shared_ptr<Socket> &sock, InetAddr &client)
                     {this->HandlerHttpRquest(sock, client); });
    }
    ~Http()
    {
    }

private:
    std::unique_ptr<TcpServer> tsvrp;
};