【项目实战】自主实现 HTTP 项目（一）——tcp、http的创建与实现较兼容的行读取

URL 是 URI 的子集。任何东西，只要能够唯一地标识出来，都可以说这个标识是 URI 。如果这个标识是一个可获取到上述对象的路径，那么同时它也可以是一个 URL ；但如果这个标识不提供获取到对象的路径，那么它就必然不是URL 。

举个例子：

URI: /home/index.html

URL: www.xxx.com:/home/index.html

http://host [":"port][abs_path]

如果用户的URL没有指明要访问的某种资源（路径），虽然浏览器默认会添加/，但是依旧没有告知服务器，要访问什么资源，此时默认返回对应服务的首页。

回车一下你会发现：

来完成TCP套间字的 创建，绑定，监听

    1 #pragma once                                                                   
    2 
    3 #include 
    4 #include 
    5 #include 
    6 #include 
    7 #include 
    8 #include 
    9 #include 
   10 #include 
   11 #include 
   12 
   13 #define BACKLOG 5
   14 
   15 class TcpServer{
   16     private:
   17         int port;
   18         int listen_sock;
   19         static TcpServer *svr;
   20     private:
   21         TcpServer(int _port):port(_port),listen_sock(-1)
   22         {}
   23         TcpServer(const TcpServer &s){}
   24     public:
   25         static TcpServer *getinstance(int port)
   26         {
   27             static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
   28             if(nullptr == svr){
   29                 pthread_mutex_lock(&lock);
   30                 if(nullptr == svr){
   31                     svr = new TcpServer(port);
   32                     svr->InitServer();
   33                 }
   34                 pthread_mutex_unlock(&lock);
   35             }
   36             return svr;
   37         }
   38         void InitServer()
   39         {
   40             Socket();
   41             Bind();
   42             Listen();
   43         }
   44         void Socket()
   45         {
   46             listen_sock = socket(AF_INET, SOCK_STREAM, 0);                     
   47             if(listen_sock < 0){
   48              exit(1);
   49             }
   50             int opt = 1;
   51             setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)      );

对于这个地方内容还是不太清楚的，可以看一下下面这个博主的分享：

网络编程套接字（二）_2021dragon的博客-CSDN博客

说明：这个地方我们先多一步，把它设计成单例模式，这样的话更有利于在后面的文件中直接使用tcpserver，而临界资源需要引入互斥锁。

tcp测试

我们可以对刚刚写的代码进行一下测试：

#include"TcpServer.hpp"
#include
#include
 
 
static void Usage(std::string proc)
{
   std::cout <<"Usage: \n\t" <"  prot "<< std::endl; 
}
 
 
int main(int argc,char *argv[])
 
{
  if(argc != 2){
    Usage(argv[0]);
    exit(4);
  }
  int port =atoi(argv[1]);
  TcpServer *svr = TcpServer::getinstance(port);
 
  for(;;)
  {
  }
  return 0;
 
}

说明：

1.这里的Usage是使用手册，当启动客户端的时候输入参数不合法（参数错误或者参数缺少）时候，就会告诉你怎么使用，这就是手册，如下图：

 这个时候我们没有输入端口号，手册会提示我们，要进行端口号的输入。

2.这里我们先写一个死循环，仅仅是来测试我们之前写的内容没有什么问题。

这个时候我们通过监视看到，端口号8081的tcp启动，并且为监听状态，说明我们之前写的内容没有什么问题，接下来我们进行下一步的实现。

---

创建HTTP服务端

接下来，我们就开始写HTTP的请求：

#pragma once 
 
#include 
#include 
#include"Protocol.hpp"
#include "TcpServer.hpp"
 
#define PORT 8081
 
class HttpServer{
private:
    int port;
    TcpServer *tcp_server;
    bool stop;
public:
    HttpServer(int _port = PORT):port(_port),tcp_server(nullptr),stop(false)
    {}
    
    void InitServer()
    {
      tcp_server =TcpServer::getinstance(port);
    }
     
    void Loop()
    {
      int listen_sock = tcp_server->Sock();
      while(!stop){
        struct sockaddr_in peer;
        socklen_t len =sizeof(peer);
        int sock =accept(listen_sock,(struct sockaddr*)&peer,&len);
        if(sock < 0 ){
          continue;
        }
        int *_sock = new int(sock);
        pthread_t tid;
        pthread_create(&tid,nullptr,Entrance:: HandlerRequest,_sock);
       
         pthread_detach(tid);   
 
      }
    }
    
    
    ~HttpServer()
    {}
};

说明：

1.我们先完成HTTP的初始化，获取一个tcp的对象，拿到其监听套件字，从底层连接队列拿到任务套件字，创建一个线程，线程分离，使得任务套件字去执行对应的任务。

2.这个地方要说明一下的是， int *_sock = new int(sock)  只是暂时的一个方案，sock在中间处理的过程中可能会被修改，这样我们先new一下，后面讲解到任务Task的时候再把这里优化掉。

HTTP服务端测试

执行方法

刚才  HandlerRequest,_sock 中的方法是什么呢，这里我们就是先让其去打印我们获取到的链接，然后打印对应的文件描述符，然后关闭我们对应的文件描述符。

#include
#include
#include
#include
 
class Entrance{
    public:
      static void *HandlerRequest(void *_sock)
      {
        int sock =*(int*)_sock;
        delete (int*)_sock;
        std::cout<<"get a new link ..."<
        close(sock);
        return nullptr;
      }
 
};

 主文件修改调试：

那么对应的，主文件中的也要稍作调整，不再是测试TcpServer了，而是测试HttpServer，创建对应的一个对象，初始化，启动。

#include"HttpServer.hpp"
#include
#include
#include
 
 
static void Usage(std::string proc)
{
   std::cout <<"Usage: \n\t" <"  prot "<< std::endl; 
}
 
 
int main(int argc,char *argv[])
 
{
  if(argc != 2){
    Usage(argv[0]);
    exit(4);
  }
  int port =atoi(argv[1]);
  std::shared_ptr http_server(new HttpServer(port));
 
  http_server->InitServer();
  http_server->Loop();
 
  return 0;
 
}

然后编译、链接通过，我们进行测试一下。

 我们可以看到，现在已经启动起来了，我们尝试用浏览器对他进行一下访问。

发现有很多链接打印，证明链接成功了。

报文打印测试

这个时候我们其实可以做一个更加深入一点的测试，我们想看一看在服务器一段接收到的信息是什么样子的，我们可以具体来看一下。

我们可以设置一个接收的buffer，设置成4KB的大小，在套件字中读取数据，去获取报文的具体内容。

#include
#include
#include
#include
 
class Entrance{
    public:
      static void *HandlerRequest(void *_sock)
      {
        int sock =*(int*)_sock;
        delete (int*)_sock;  
       
        std::cout<<"get a new link ..."<
 
        //For Test
        char buffer[4096];
        recv(sock,buffer,sizeof(buffer),0);
        std::cout<<"-------------------begin--------------------"<
        std::cout<
        std::cout<<"-------------------end--------------------"<
 
        close(sock);
        return nullptr;
      }
 
};

这个时候我们再编译链接通过，用我们的浏览器进行访问。

 这个时候我们可以看到：

 拿到了我们的报文，那么报文具体是什么意思呢，我们接着往下看

 略谈报文

【说明】：

1.POST 是请求方法

2.HTTP 后面跟的是版本

2.剩下的都是以key：value 的形式的属性

包括 主机号：XXXX  连接方式：是长连接的XXX（Key：value）

这里重点是这个GET 后面的 / 是不是linux服务器的根目录开始呢？

不一定，通常不会设置成为根目录，我们通常由http服务器设置为自己的WEB根目录（就是Linux）下一个特定的路径。

           

               这个时候我们就要读取请求了，但是有的人心想，我们刚才不是已经读取了请求了吗，然而实际上，我们刚才读取的那种请求其实是不标准的，我们是按照4KB大小进行读取的，但是tcp是 面向字节流的，我们不能排除tcp同时有大量的连接请求或者大量的内容进行发送，在没有明确约定的情况下进行读取，很容易发生 数据包粘包的问题，这个时候我们就应该正确的去处理这些问题：

#pragma once
 
#include 
#include 
#include 
#include 
 
//工具类
class Util{
    public:
        static int ReadLine(int sock, std::string &out)
        {
            char ch = 'X';
            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{
                            ch = '\n';
                        }
                    }
                    //1. 普通字符
                    //2. \n
                    out.push_back(ch);
                }
                else if(s == 0){
                    return 0;
                }
                else{
                    return -1;
                }
            }
            return out.size();
        }
}；

【说明】：

● 本机制的原理如上，如果是\n，则不用处理，为正常的一行分割为获取一个字符

● 首先判断是否是‘ \r ‘，这个时候有两种可能，一种是/r  还有一种是 /r/n，我们这里需要统一处理成\n，达到我们的目的。

● 当拿到\r的时候，这时候需要确定下一个字符是否为\n，我们这里需要进行探测，注意，我们不能直接读取下一个数据，如果下一个不是\n，那么读取后直接已经拿到接收缓冲区，相当于多读了下一行的开头，是绝对不能允许的，所以我们要进行探测，即把recv的第三个参数设成 MSG_PEEK，就会进行下一次的探测，不会直接读到接收缓冲区。

我们用浏览器再进行一下测试：

我们可以看到：