【Linux】HTTP协议

已于 2023-06-11 10:56:17 修改
阅读量1.4k 收藏 1
点赞数 1
文章标签： linux http 网络
于 2023-06-09 00:01:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59400943/article/details/131056035
版权

目录

🚀前言

本篇文章进行应用层中HTTP协议的学习！！！

🚃HTTP协议

前言：应用层协议都是人定的，在以前有一些大佬定的好用的应用层协议，供我们直接参考使用，后面就变成了标准，HTTP就在其中

  • 应用层的作用主要是向用户提供应用服务时的通信活动

  • http协议：又名超文本传输协议，是一个简单的网络请求和响应协议，它通常运行在传输层之上的应用层

  • 它指定了客户端可能发送给服务器什么样的消息以及得到什么样的响应

  • HTTP协议主要是在网络中传输图片、音频、视频等网络资源，把这些丰富的资源都呈现在一个网站上，正是因为它可以传输任何资源，所以才叫超文本传输协议

🚄1、URL网址

前言：平时我们经常说的访问某某某网址，其实就是说访问某某某URL！！！

在这里插入图片描述

URL中的字段

  • 第一个字段是协议名

  • 第二个字段中的登录信息(用户名和密码)一般不在URL中明文传输，一般都是通过请求正文加密进行传输

  • 第三个字段是网址的域名，域名可以通过DNS服务转换成IP地址，然后通过对应的端口号标定网络中唯一的进程

  • 第四个字段中的第一个斜杠是Web根目录，它可以被设置为根目录，也可以设置为其他路径作为web根目录（相对路径），后面访问的文件是这个网址要在服务器获取的资源（index.html）

  • 查询字符串用于向服务器传递参数，格式为?key=value&key2=value2，其中?key=value表示为第一个参数，&用于分隔多个参数，GET方法请求可以直接将参数以明文方式添加到URL中

  • 片段标识符用于指定文档中特定的部分，格式为#fragment，其中#表示片段标识符开始，fragment表示文档中特定的部分。主要用于跳转到文档的特定位置

  • 总结：URL就是通过某种协议获取某个主机中的某种资源，拉取到网站本地中，如果是html，浏览器可以自动解析

🚅2、URL的编码和解码

【URL编码解码在线网页工具】

编码
  • 当使用URL进行传参时，如果存在特殊字符或汉字时，会对其进行转义（编码）【url特殊字符】
  • 比如问号和加号等特殊字符，它们已经被URL当做特殊意义理解了，因此这些字符不能随意出现
  • 编码规则：将需要转码的字符转为16进制，然后从右到左，取4位(不足4位直接处理)，每2位做一位，前面加上%，编码成%XY格式

搜关键字通过utl传参，“+” 被转义成了 %2B

在这里插入图片描述

汉字通过url进行传参后，也会对其进行编码，每个汉字转换成三个16进制的数据

在这里插入图片描述

解码
  • 解码就是编码的逆过程，首先去掉%，然后将16进制数据转换成十进制，然后通过ASCII表转换成对应的特殊字符即可！！！

在这里插入图片描述

🚇3、HTTP协议格式

HTTP请求
  • HTTP请求包含：请求行、请求报头、空行和请求正文（有效载荷）这四个部分，空行是用来分离请求报头和请求正文（有效载荷）的分隔符
  • 首行：[方法] + [url] + [HTTP版本]
  • 请求报头(Header)：请求报头内的属性可以有多个，请求的属性是冒号分割的键值对；每组属性之间使用“\r\n”分隔；遇到空行(“\r\n”)表示Header部分结束
  • 请求正文(Body)：空行后面的内容都是Body，Body允许为空字符串；如果Body存在, 则在Header中会有一个Content-Length属性来标识Body的长度

在这里插入图片描述

HTTP响应
  • HTTP响应包含：状态行、响应报头、空行和响应正文（有效载荷）这四个部分，空行是用来分离请求报头和响应正文（有效载荷）的分隔符
  • 首行：[HTTP版本号] + [状态码] + [状态码描述]
  • 请求报头(Header)：响应报头内的属性可以有多个，响应的属性是冒号分割的键值对；每组属性之间使用“\r\n”分隔；遇到空行(“\r\n”)表示Header部分结束
  • 响应正文(Body)：空行后面的内容都是Body，Body允许为空字符串；如果Body存在, 则在Header中会有一个Content-Length属性来标识Body的长度；如果服务器返回了一个html页面，那么html页面内容就是在body中

0

HTTP的请求和响应如何保证自己的报头和有效载荷被全部读取呢？

  • 读取完整报头：按行读取，直到读取到空行即读取完了报头

  • 读取完整有效载荷：报头读取完毕后，请求或响应的报头属性中，有一个属性（Content-Length）可以标识有效载荷的数据长度，按照给定的长度进行读取，就能读取到完整的正文

HTTP请求行：GET / HTTP/1.1

  • 请求行中的第二个字段是URL，而URL除了资源路径以外其他的相关字段都省略了

  • 第二个字段下的斜杠，它不是服务器的根目录，而是一个Web根目录，但是它也可以设置成为根目录，一般为服务器内相对路径下的Web根目录

  • 举个例子，我们访问baidu.com时，请求资源路径只写一个斜杠，但是baidu会给我们自动添加主页资源的路径(/index.html)，随后通过网络传输到客户端显示给用户

在这里插入图片描述

代码感受一下：首个http服务器代码

  • 该服务器只是简单的构建了http响应报头，多线程的方式进行读取请求和响应请求
#include <iostream>
#include <string>
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <thread>
#include <fstream>

#define ROOT_PATH "./wwwroot"
#define HOME "index.html"
#define CRLF "\r\n"
#define CRLF_LEN 2
#define SPACE " "
#define SPACE_LEN 1

class HttpServer
{
public:
    HttpServer(uint16_t Port, std::string Ip = "")
        : ServerIp_(Ip), ServerPort_(Port), ListenSockfd_(-1)
    {
    }

    void Init()
    {
        assert(ServerPort_ > 1024);
        ListenSockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (ListenSockfd_ < 0)
        {
            std::cout << "have socket error: " << strerror(errno) << std::endl;
            exit(1);
        }

        sockaddr_in ServerData;
        socklen_t len = sizeof(ServerData);
        memset(&ServerData, 0, len);
        ServerData.sin_family = AF_INET;
        ServerData.sin_port = htons(ServerPort_);
        ServerData.sin_addr.s_addr = ServerIp_.empty() ? htonl(INADDR_ANY) : inet_addr(ServerIp_.c_str());

        if (bind(ListenSockfd_, (const sockaddr *)&ServerData, len))
        {
            std::cout << "bind inet data error: " << strerror(errno) << std::endl;
            exit(2);
        }

        if (listen(ListenSockfd_, 2) < 0)
        {
            std::cout << "Set listen status error: " << strerror(errno) << std::endl;
            exit(3);
        }
    }

    void Start()
    {
        while (true)
        {
            int sersockfd = accept(ListenSockfd_, nullptr, nullptr);
            if (sersockfd < 0)
            {
                std::cout << "accept error: " << strerror(errno) << std::endl;
                exit(4);
            }
            // 使用线程并行的去执行服务，不影响获取连接请求
            std::thread Thread(&HttpServer::RunThread, this, sersockfd);
            Thread.detach();
        }
    }

private:
    void RunThread(int sersockfd)
    {
        std::string inbuffer;
        inbuffer.resize(1024, 0);
        // 读http请求
        ssize_t Index = read(sersockfd, (void *)inbuffer.c_str(), inbuffer.size());
        if (Index > 0)
        {
            std::cout << inbuffer << std::endl;
        }

        // 构建响应报文
        std::string RequestPath = ROOT_PATH;
        RequestPath += GetRequestPath(inbuffer);
        std::string resources = ReadFile(RequestPath);

        std::string Response;
        Response += "HTTP/1.1 200 OK\r\n"; // 请求行
        Response += "Content-Type: text/html\r\n";
        Response += ("Content-Length: ") + (std::to_string(resources.size()) + "\r\n");
        Response += "\r\n";
        Response += resources;

		// 发送响应报文
        send(sersockfd, Response.c_str(), Response.size(), 0);

        close(sersockfd); // 服务完成后关闭服务套接字
    }

private:
    std::string ReadFile(const std::string &Path)
    {
    	// 读取请求资源路径下的文件
        std::ifstream in(Path.c_str());
        if (!in.is_open())
        {
            std::cout << "open file error: " << strerror(errno) << std::endl;
            return "404";
        }
        std::string buffer;
        std::string result;
        while (std::getline(in, buffer))
        {
            result += buffer;
        }
        std::cout << result << std::endl;
        return result;
    }

    std::string GetRequestPath(std::string &inbuffer)
    {
        // "GET /a/b/c HTTP/1.1\r\n" --> "/a/b/c"
        size_t pos = inbuffer.find(CRLF);
        if (pos == std::string::npos)
            return "4xx";
        std::string RequestLine = inbuffer.substr(0, pos + CRLF_LEN);
        size_t SpaceOne = RequestLine.find(SPACE);
        size_t SpaceTwo = RequestLine.rfind(SPACE);
        if (SpaceOne == std::string::npos && SpaceTwo == std::string::npos)
            return "4xx";

        // 如果请求为'/'那么自动添加******主页的资源******
        std::string Path = RequestLine.substr(SpaceOne + SPACE_LEN, SpaceTwo - (SpaceOne + SPACE_LEN));
        if (Path.size() == 1 && Path[0] == '/')
        {
            Path += HOME;
        }
        return Path;
    }

private:
    std::string ServerIp_;
    uint16_t ServerPort_;
    int ListenSockfd_;
};

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        std::cout << "Format: ./可执行程序 [ip] port" << std::endl;
        exit(5);
    }
    std::string ip;
    uint16_t port;
    if (argc == 3)
    {
        ip = argv[1];
        port = std::stoi(argv[2]);
    }
    else
    {
        port = std::stoi(argv[1]);
    }

    HttpServer hs(port, ip);
    hs.Init();
    hs.Start();
    return 0;
}

在这里插入图片描述

运行结果

在这里插入图片描述

🚈4、HTTP请求

HTTP请求行中的请求方法有如下图所示：

在这里插入图片描述

🚉4.1、 HTTP GET和POST方法

我们的网络行为无非有两种：

  • 我想把远端服务器的某种资源拿到你的本地（GET /index.html）

  • 我们想把我们的属性字段（比如搜索关键字或用户名和密码等等），提交到远端服务器中

  • 传参时，是使用html中一个表单的东西进行传递参数的

GET方法

  • GET方法是用于获取服务器中某个路径下的某种资源，可以向服务器进行传参

  • 我们想把我们的属性字段提交到远端，可以使用GET方法进行传参

  • 在HTTP协议中GET方法会以明文的方式将我们对应的参数信息，拼接到URL中传参

  • 前面说的URL中查询字符串字段，GET方法就是把参数拼接到这里，格式为?key=value&key2=value2，&为参数间的分隔符，参数的格式是以键值对的方式进行传参

POST方法

  • POST方法也可以获取服务器中某个路径下的某种资源，也可以向服务器进行传参

  • POST方法传参时，会将参数以明文的方式，拼接到http请求正文中进行提交

  • 提交参数时也是以?key=value&key2=value2这样的格式进行传参，&为参数间的分隔符，参数的格式是以键值对的方式进行传参

GET vs POST

  • GET方法通过URL进行传参

  • POST通过请求正文（有效载荷）进行传参

  • GET方法传参不私密，因为懂些网络的人，就知道你传的参数是什么了

  • POST方法通过正文传参，相对比较私密一些（有些人不会抓包）

  • GET通过URL传参，POST通过正文传参，一般传一些比较大的内容都是通过POST的方式进行传参的，因为正文有报头属性（Content-Type）来标定正文数据类型是什么

  • GET方法以前是会限定传参内容大小的，现在已经可以无限制了，但是传输的数据类型只能是文本（text/html），所以还是使用POST以正文的方式进行传参，还能识别数据类型

验证是否正确：

当前路径下wwwroot下的index.html文件

  • 这里使用html语法中的表单进行传参，不会的可以学一下html的语法
<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <title>测试网页</title>
</head>

<body>
    <h3>hello my server!</h3>
    <p>我终于测试完了我的代码</p>
    <form action="/a/b/c.html" method="post">
        Username: <input type="text" name="user"><br>
        Password: <input type="password" name="passwd"><br>
        <input type="submit" value="Submit">
    </form>
    <!-- <img border="0" src="https://img1.baidu.com/it/u=1691233364,820181697&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500" alt="Pulpit rock" width="304" height="228"> -->
</body>

</html>

HttpServer.cc

#include "Util.h"
#include <thread>
#include <fstream>

#define ROOT_PATH "./wwwroot"
#define HOME "index.html"
#define CRLF "\r\n"
#define CRLF_LEN 2
#define SPACE " "
#define SPACE_LEN 1

class HttpServer
{
public:
    HttpServer(uint16_t Port, std::string Ip = "")
        : ServerIp_(Ip), ServerPort_(Port), ListenSockfd_(-1)
    {
    }

    void Init()
    {
        assert(ServerPort_ > 1024);
        ListenSockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (ListenSockfd_ < 0)
        {
            std::cout << "have socket error: " << strerror(errno) << std::endl;
            exit(1);
        }

        sockaddr_in ServerData;
        socklen_t len = sizeof(ServerData);
        memset(&ServerData, 0, len);
        ServerData.sin_family = AF_INET;
        ServerData.sin_port = htons(ServerPort_);
        ServerData.sin_addr.s_addr = ServerIp_.empty() ? htonl(INADDR_ANY) : inet_addr(ServerIp_.c_str());

        if (bind(ListenSockfd_, (const sockaddr *)&ServerData, len))
        {
            std::cout << "bind inet data error: " << strerror(errno) << std::endl;
            exit(2);
        }

        if (listen(ListenSockfd_, 4) < 0)
        {
            std::cout << "Set listen status error: " << strerror(errno) << std::endl;
            exit(3);
        }
    }

    void Start()
    {
        while (true)
        {
            int sersockfd = accept(ListenSockfd_, nullptr, nullptr);
            if (sersockfd < 0)
            {
                std::cout << "accept error: " << strerror(errno) << std::endl;
                exit(4);
            }
            // 使用线程并行的去执行服务，不影响获取连接请求
            std::thread Thread(&HttpServer::RunThread, this, sersockfd);
            Thread.detach();
        }
    }

private:
    void RunThread(int sersockfd)
    {
        // char inbuffer[1024];
        std::string inbuffer;
        inbuffer.resize(1024, 0);
        ssize_t Index = read(sersockfd, (void *)inbuffer.c_str(), inbuffer.size());
        if (Index > 0)
        {
            std::cout << inbuffer << std::endl;
        }

        // 发响应报文
        std::string RequestPath = ROOT_PATH;
        RequestPath += GetRequestPath(inbuffer);
        std::string resources = ReadFile(RequestPath);

        std::string Response;
        Response += "HTTP/1.1 200 OK\r\n";
        Response += "Host: " + (ServerIp_.empty() ? "0.0.0.0" : ServerIp_) + ":" + \
                    std::to_string(ServerPort_) + "\r\n";
        Response += "Content-Type: text/html\r\n";
        Response += ("Content-Length: ") + (std::to_string(resources.size()) + "\r\n");
        Response += "\r\n";
        Response += resources;

        send(sersockfd, Response.c_str(), Response.size(), 0);

        close(sersockfd);
    }

private:
    std::string ReadFile(const std::string &Path)
    {
        std::ifstream in(Path.c_str());
        if (!in.is_open())
        {
            std::cout << "open file error: " << strerror(errno) << std::endl;
            return "404";
        }
        std::string buffer;
        std::string result;
        while (std::getline(in, buffer))
        {
            result += buffer;
        }
        return result;
    }

    std::string GetRequestPath(std::string &inbuffer)
    {
        // "GET /a/b/c HTTP/1.1\r\n" --> "/a/b/c"
        size_t pos = inbuffer.find(CRLF);
        if (pos == std::string::npos)
            return "4xx";
        std::string RequestLine = inbuffer.substr(0, pos + CRLF_LEN);
        size_t SpaceOne = RequestLine.find(SPACE);
        size_t SpaceTwo = RequestLine.rfind(SPACE);
        if (SpaceOne == std::string::npos && SpaceTwo == std::string::npos)
            return "4xx";

        // 如果请求为'/'那么自动添加主页的资源
        std::string Path = RequestLine.substr(SpaceOne + SPACE_LEN, SpaceTwo - (SpaceOne + SPACE_LEN));
        if (Path.size() == 1 && Path[0] == '/')
        {
            Path += HOME;
        }
        return Path;
    }

private:
    std::string ServerIp_;
    uint16_t ServerPort_;
    int ListenSockfd_;
};

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        std::cout << "Format: ./可执行程序 [ip] port" << std::endl;
        exit(5);
    }
    std::string ip;
    uint16_t port;
    if (argc == 3)
    {
        ip = argv[1];
        port = std::stoi(argv[2]);
    }
    else
    {
        port = std::stoi(argv[1]);
    }

    HttpServer hs(port, ip);
    hs.Init();
    hs.Start();
    return 0;
}

GET方法

在这里插入图片描述

在这里插入图片描述

POST方法

在这里插入图片描述

在这里插入图片描述

其他方法

【摘至☞developer.mozilla.org】

  • PUT：PUT请求方法是一种将数据添加到指定URL中的操作，可以用于更新服务器上的数据或创建新的资源

  • HEAD：HEAD请求方法用于获取服务端的请求行和报头

  • DELETE：DELETE请求方法用于删除服务端的指定资源

  • OPTIONS：OPTIONS请求方法用于获取服务端所支持的请求方法

  • TRACE：TRACE请求方法沿着通往目标资源的路径进行信息回环测试，提供一个有用的调试机制

  • CONNECT：CONNECT请求方法可以开启与所请求资源之间的双向沟通的通道；它可以用来创建隧道（tunnel）

🚋4.2、HTTP状态码

【HTT状态码 – 百度百科】
在这里插入图片描述

  • 状态码：状态码是服务器响应客户端请求时在状态行填充的字段，包含状态码和状态码描述

  • 1xx：该状态码表示接收的请求报文正在处理中，稍后会响应一个完整的响应报文。100的状态码描述为Continue，101状态码描述为Switching Protocols

  • 2xx：该状态码表示请求已成功被服务器接收、理解、并接受（但不代表已经处理）。200状态码描述为OK；201状态码描述为Created；202状态码描述为Accepted

  • 3xx：该状态码需要客户端采取进一步的操作才能完成请求，用于进行重定向（请求的URL可能临时进行维护或永久失效了），后续通过请求报头属性中的Location可以重定向到新的URL。300状态码描述为Multiple Choices（临时重定向）；301状态码描述为Moved Permanently（永久重定向）

  • 4xx：该状态码表示客户端发送请求有问题，可能请求报文没有按照要求进行编写或请求的资源不存在等等。403状态码描述为Forbidden（有权限访问此网站），404状态码描述为Not Found（请求资源不存在）

  • 5xx：该状态码表示服务器在处理请求的过程中有错误或者异常状态发生（内存不足或程序异常等），500状态码描述为Internal Server Error，502状态码描述为Bad Gateway

响应报文中状态行格式如下：

在这里插入图片描述

🚊4.3、HTTP常见Header

HTTP常见报头：

  • Content-Type：用于标定正文的数据类型（text/html等）【Content-Type对照表】

  • Content-Length：用于标定正文（Body）的长度，方便正确的读取正文数据大小

  • Host：客户端告知服务器，所请求的资源是在哪个主机的哪个端口上(格式ip:port)

  • User-Agent：声明（获取）用户的操作系统和浏览器版本信息

  • Referer：当前页面是从哪个页面跳转过来的

  • Location：搭配3xx状态码使用，告诉客户端接下来要去哪里访问重定向后的url

  • Cookie: 用于在客户端存储少量信息（用户名和密码），通常用于实现会话(session)保持的功能

状态码3xx和响应报头属性Location字段的关系

  • 3xx状态码告诉用户要访问的网站正在进行维护或永久下架了

  • 客户端收到响应报头属性Location字段后，会根据Location字段的值进行重定向或跳转操作，如果需要进行重定向操作，客户端会发送新的请求（二次请求），请求的URL地址为Location字段的值

  • 注意：Location字段的值必须是完整的URL，不能是baidu.com这样不带协议名的URL，必须携带使用的协议名（https://www.baidu.com/）

代码看构建响应报文的部分即可

#include "Util.h"
#include <thread>
#include <fstream>

#define ROOT_PATH "./wwwroot"
#define HOME "index.html"
#define CRLF "\r\n"
#define CRLF_LEN 2
#define SPACE " "
#define SPACE_LEN 1

class HttpServer
{
public:
    HttpServer(uint16_t Port, std::string Ip = "")
        : ServerIp_(Ip), ServerPort_(Port), ListenSockfd_(-1)
    {
    }

    void Init()
    {
        assert(ServerPort_ > 1024);
        ListenSockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (ListenSockfd_ < 0)
        {
            std::cout << "have socket error: " << strerror(errno) << std::endl;
            exit(1);
        }

        sockaddr_in ServerData;
        socklen_t len = sizeof(ServerData);
        memset(&ServerData, 0, len);
        ServerData.sin_family = AF_INET;
        ServerData.sin_port = htons(ServerPort_);
        ServerData.sin_addr.s_addr = ServerIp_.empty() ? htonl(INADDR_ANY) : inet_addr(ServerIp_.c_str());

        if (bind(ListenSockfd_, (const sockaddr *)&ServerData, len))
        {
            std::cout << "bind inet data error: " << strerror(errno) << std::endl;
            exit(2);
        }

        if (listen(ListenSockfd_, 4) < 0)
        {
            std::cout << "Set listen status error: " << strerror(errno) << std::endl;
            exit(3);
        }
    }

    void Start()
    {
        while (true)
        {
            int sersockfd = accept(ListenSockfd_, nullptr, nullptr);
            if (sersockfd < 0)
            {
                std::cout << "accept error: " << strerror(errno) << std::endl;
                exit(4);
            }
            // 使用线程并行的去执行服务，不影响获取连接请求
            std::thread Thread(&HttpServer::RunThread, this, sersockfd);
            Thread.detach();
        }
    }

private:
    void RunThread(int sersockfd)
    {
        // char inbuffer[1024];
        std::string inbuffer;
        inbuffer.resize(1024, 0);
        ssize_t Index = read(sersockfd, (void *)inbuffer.c_str(), inbuffer.size());
        if (Index > 0)
        {
            std::cout << inbuffer << std::endl;
        }

        // 发响应报文
        std::string RequestPath = ROOT_PATH;
        RequestPath += GetRequestPath(inbuffer);
        std::string resources = ReadFile(RequestPath);

        std::string Response;
        Response += "HTTP/1.1 300 Multiple Choices\r\n";
        Response += "Host: " + (ServerIp_.empty() ? "0.0.0.0" : ServerIp_) + ":" + \
                    std::to_string(ServerPort_) + "\r\n";
        Response += "Content-Type: text/html\r\n";
        Response += ("Content-Length: ") + (std::to_string(resources.size()) + "\r\n");
        Response += "Location: https://www.baidu.com/\r\n";
        Response += "\r\n";
        Response += resources;

        send(sersockfd, Response.c_str(), Response.size(), 0);

        close(sersockfd);
    }

private:
    std::string ReadFile(const std::string &Path)
    {
        std::ifstream in(Path.c_str());
        if (!in.is_open())
        {
            std::cout << "open file error: " << strerror(errno) << std::endl;
            return "404";
        }
        std::string buffer;
        std::string result;
        while (std::getline(in, buffer))
        {
            result += buffer;
        }
        return result;
    }

    std::string GetRequestPath(std::string &inbuffer)
    {
        // "GET /a/b/c HTTP/1.1\r\n" --> "/a/b/c"
        size_t pos = inbuffer.find(CRLF);
        if (pos == std::string::npos)
            return "4xx";
        std::string RequestLine = inbuffer.substr(0, pos + CRLF_LEN);
        size_t SpaceOne = RequestLine.find(SPACE);
        size_t SpaceTwo = RequestLine.rfind(SPACE);
        if (SpaceOne == std::string::npos && SpaceTwo == std::string::npos)
            return "4xx";

        // 如果请求为'/'那么自动添加主页的资源
        std::string Path = RequestLine.substr(SpaceOne + SPACE_LEN, SpaceTwo - (SpaceOne + SPACE_LEN));
        if (Path.size() == 1 && Path[0] == '/')
        {
            Path += HOME;
        }
        return Path;
    }

private:
    std::string ServerIp_;
    uint16_t ServerPort_;
    int ListenSockfd_;
};

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        std::cout << "Format: ./可执行程序 [ip] port" << std::endl;
        exit(5);
    }
    std::string ip;
    uint16_t port;
    if (argc == 3)
    {
        ip = argv[1];
        port = std::stoi(argv[2]);
    }
    else
    {
        port = std::stoi(argv[1]);
    }

    HttpServer hs(port, ip);
    hs.Init();
    hs.Start();
    return 0;
}

关于Cookie字段和Session详解

  • HTTP协议的特定之一：它是无状态的（客户端发送请求和服务器响应请求时的报文都不会被保存起来，发完后就直接丢弃了）

  • 如果我们要看电影，访问了一个网站，这些电影要登录账号才能免费观看，如果HTTP是无状态的话，请求报文中传参的用户名和密码都会被丢弃，那用户每请求一个新的电影资源都要进行重新登录！！

  • 解法方法就是在这个网站中保持用户的登录状态（会话保持），但是保持登录数据就要将请求的报文存储起来，每次请求和响应都要保存，会很费内存

  • Cookie：它是一个在客户端存储数据的小型文本文件，由服务器发给客户端（响应属性字段Set-Cookie），然后客户端将其存储在本地（浏览器维护，可能存储在磁盘或内存）。每次客户端向服务器发送请求时，Cookie会随请求一起发送到服务器（自动填充请求报头属性Cookie）

在这里插入图片描述

  • Session：由于Cookie存储在客户端，因此很容易被篡改和盗取，而Session是一种在服务端存储数据的机制，当用户第一次访问网站时，会为其创建一个唯一的Session ID，并将其存储在Cookie中（Cookie其他数据都保存在服务器端中，后面通过Session ID进行校验），后面客户端向服务器发送请求时，服务器会根据Session ID查找对应的Session数据

  • 通俗的说就是：客户端传参用户名密码给服务器，服务器创建session文件来保存用户名和密码等私密信息，然后将session文件名（session ID）放到响应报头属性Set-Cookie中，后面客户端请求报头属性中的Cookie每次都会携带session ID来进行用户认证！

在这里插入图片描述

看代码中的构建报文部分

#include "Util.h"
#include <thread>
#include <fstream>

#define ROOT_PATH "./wwwroot"
#define HOME "index.html"
#define CRLF "\r\n"
#define CRLF_LEN 2
#define SPACE " "
#define SPACE_LEN 1

class HttpServer
{
public:
    HttpServer(uint16_t Port, std::string Ip = "")
        : ServerIp_(Ip), ServerPort_(Port), ListenSockfd_(-1)
    {
    }

    void Init()
    {
        assert(ServerPort_ > 1024);
        ListenSockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (ListenSockfd_ < 0)
        {
            std::cout << "have socket error: " << strerror(errno) << std::endl;
            exit(1);
        }

        sockaddr_in ServerData;
        socklen_t len = sizeof(ServerData);
        memset(&ServerData, 0, len);
        ServerData.sin_family = AF_INET;
        ServerData.sin_port = htons(ServerPort_);
        ServerData.sin_addr.s_addr = ServerIp_.empty() ? htonl(INADDR_ANY) : inet_addr(ServerIp_.c_str());

        if (bind(ListenSockfd_, (const sockaddr *)&ServerData, len))
        {
            std::cout << "bind inet data error: " << strerror(errno) << std::endl;
            exit(2);
        }

        if (listen(ListenSockfd_, 4) < 0)
        {
            std::cout << "Set listen status error: " << strerror(errno) << std::endl;
            exit(3);
        }
    }

    void Start()
    {
        while (true)
        {
            int sersockfd = accept(ListenSockfd_, nullptr, nullptr);
            if (sersockfd < 0)
            {
                std::cout << "accept error: " << strerror(errno) << std::endl;
                exit(4);
            }
            // 使用线程并行的去执行服务，不影响获取连接请求
            std::thread Thread(&HttpServer::RunThread, this, sersockfd);
            Thread.detach();
        }
    }

private:
    void RunThread(int sersockfd)
    {
        // char inbuffer[1024];
        std::string inbuffer;
        inbuffer.resize(1024, 0);
        ssize_t Index = read(sersockfd, (void *)inbuffer.c_str(), inbuffer.size());
        if (Index > 0)
        {
            std::cout << inbuffer << std::endl;
        }

        // 发响应报文
        std::string RequestPath = ROOT_PATH;
        RequestPath += GetRequestPath(inbuffer);
        std::string resources = ReadFile(RequestPath);

        std::string Response;
        Response += "HTTP/1.1 200 OK\r\n";
        Response += "Host: " + (ServerIp_.empty() ? "0.0.0.0" : ServerIp_) + ":" + \
                    std::to_string(ServerPort_) + "\r\n";
        Response += "Content-Type: text/html\r\n";
        Response += ("Content-Length: ") + (std::to_string(resources.size()) + "\r\n");
        Response += "Location: https://www.baidu.com/\r\n";
        Response += "Set-Cookie: This is my cookie\r\n";
        Response += "\r\n";
        Response += resources;

        send(sersockfd, Response.c_str(), Response.size(), 0);

        close(sersockfd);
    }

private:
    std::string ReadFile(const std::string &Path)
    {
        std::ifstream in(Path.c_str());
        if (!in.is_open())
        {
            std::cout << "open file error: " << strerror(errno) << std::endl;
            return "404";
        }
        std::string buffer;
        std::string result;
        while (std::getline(in, buffer))
        {
            result += buffer;
        }
        return result;
    }

    std::string GetRequestPath(std::string &inbuffer)
    {
        // "GET /a/b/c HTTP/1.1\r\n" --> "/a/b/c"
        size_t pos = inbuffer.find(CRLF);
        if (pos == std::string::npos)
            return "4xx";
        std::string RequestLine = inbuffer.substr(0, pos + CRLF_LEN);
        size_t SpaceOne = RequestLine.find(SPACE);
        size_t SpaceTwo = RequestLine.rfind(SPACE);
        if (SpaceOne == std::string::npos && SpaceTwo == std::string::npos)
            return "4xx";

        // 如果请求为'/'那么自动添加主页的资源
        std::string Path = RequestLine.substr(SpaceOne + SPACE_LEN, SpaceTwo - (SpaceOne + SPACE_LEN));
        if (Path.size() == 1 && Path[0] == '/')
        {
            Path += HOME;
        }
        return Path;
    }

private:
    std::string ServerIp_;
    uint16_t ServerPort_;
    int ListenSockfd_;
};

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        std::cout << "Format: ./可执行程序 [ip] port" << std::endl;
        exit(5);
    }
    std::string ip;
    uint16_t port;
    if (argc == 3)
    {
        ip = argv[1];
        port = std::stoi(argv[2]);
    }
    else
    {
        port = std::stoi(argv[1]);
    }

    HttpServer hs(port, ip);
    hs.Init();
    hs.Start();
    return 0;
}

服务器发送Cookie后，会在网站上的cookie中找到相关数据

在这里插入图片描述

格式化、、
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
HTTP.rar_http linux_linux http协议
09-14
在这个“HTTP.rar_http linux_linux http协议”压缩包中，重点是关于在Linux环境下理解和操作HTTP协议的知识点。下面我们将深入探讨这个主题。 首先，我们来了解HTTP请求报头。HTTP请求由三部分组成：方法行、请求...
在Linux上实现HTTP请求
weixin_73725158的博客
04-13 1358
Linux
linux篇【14】：网络http协议
zhang_si_hang的博客
01-13 3033
认识URL，http协议的请求与响应，telnet 命令，初步使用html，表单，GET Vs POST
Linux：http配置用户登录认证访问网页
最新发布
fox_kang的博客
04-27 530
【代码】Linux：http配置用户登录认证访问网页。
Linux网络编程----http
qq_48083892的博客
02-17 1636
Linux网络编程----http
Linux——HTTP协议
qq_44824574的博客
02-01 1380
超文本传输协议（HTTP，HyperText Transfer Protocol) 互联网上应用最为广泛的一种网络协议。所有的WWW文件都必须遵守这个标准。设计HTTP最初的目的是为了提供一种发布和接收HTML页面的方法 HTTP协议的作用 HTTP是一个客户端和服务器端请求和应答的标准，浏览器与后台web服务器之间传递数据（html文件）时控制的协议。 区分HTML HTML超文本标记语言，通过不同的标签来标识数据的不同样式或作用。 区分HTTPS 一种安全的超文本传输协议，密文形式传输（SSL） H
linux网络http
m0_51641706的博客
03-17 2097
文章目录自定义协议http 协议是一种 “约定”. socket api的接口, 在读写数据时, 都是按 “字符串” 的方式来发送接收的. 如果我们要传输一些"结构化的数据" 怎么办呢? 协议就要出现了。所谓协议就是大家都按照这个规定发送数据给服务器，服务器都按照这个规定发送数据给本地。 自定义协议 定义结构体发送信息到网络叫序列化，定义结构体从网络发到本地叫反序列化 序列化反序列化用工具 json xml http url，url就是网址。 登录信息一般是不显示的，忽略的。 服务器端口是不可以省略的，
shttp.rar_POST_SHTTP协议_linux http get post_linux http协议_shttp
09-24
【标签】中的关键词"post"、"shttp协议"、"linux_http_get_post"和"linux_http协议"是对标题内容的进一步细化，它们突出了实现的关键特性：POST请求、SHTTP协议的实现、Linux环境下的HTTP GET和POST操作。...
web_server.zip_Linux http协议_http server_http服务器_http服务器端_web_s
07-14
模拟http服务器 模拟http协议的一个服务器端 运行之后能用IE连接
http.rar_HTTP协议_Linux http_linux http
09-23
在本文中，我们将深入探讨HTTP协议的原理、工作方式以及如何在Linux环境下进行相关操作。同时，我们注意到文件“http.c”，这可能是用于解析HTTP协议的源代码，暗示我们将讨论HTTP协议的编程实现。 1. HTTP协议基础...
linux TCPIP 协议栈.pdf
08-11
Linux TCP/IP协议栈是Linux操作系统核心网络通信的基础，它负责处理网络数据的传输，包括接收、处理和发送网络包。本教程将深入探讨Linux内核中的TCP/IP协议栈原理及源代码分析，帮助读者理解其工作流程和实现细节。...
linux网络协议开发文档.doc
01-15
Linux内核网络协议开发文档由Jammy.wang编写，详细阐述了在Linux系统下如何进行网络协议的开发工作。这份文档覆盖了从物理层到网络层的重要概念和技术，为开发者提供了一个深入理解Linux网络协议栈的指导。 1. **一...
linux环境下支持http和ftp双协议下载
04-28
HTTP协议是一种应用层协议，主要用于Web浏览器与Web服务器之间的通信。它简单、快速，适用于分布式超媒体信息系统。HTTP协议工作于TCP/IP协议之上，通过TCP连接发送和接收数据。在Linux中，可以使用多种工具进行HTTP...
linux c 通过http 协议 ，上传文件到服务器 源码
03-01
linux c 通过http 协议 ，上传文件到服务器 源码
linux项目工程资料-Linux下基于C语言与HTTP协议网站打开指定文件目录可进行不同操作.zip
03-02
Linux项目是一个开放源代码的操作系统项目，由林纳斯·托瓦兹（Linus Torvalds）于1991年首次发布。该项目以Linux内核为核心，围绕其构建了一个完整的操作系统，包括各种系统工具、库、应用程序和硬件支持。 以下是...
linux内核协议栈剖析
06-02
《Linux内核协议栈剖析》一书主要涵盖了Linux操作系统中网络协议栈的深入解析，特别是TCP/IP协议栈的实现细节。TCP/IP协议栈是互联网通信的核心部分，它负责在网络之间传输数据包，确保数据的正确性和可靠性。在...
【Linux】Http协议
Edward_Asia的博客
10-29 1898
Http协议
linux发送http请求收集
daodfs1的博客
07-17 385
json数据要放在单引号里面。json数据要放在单引号里面。key3的值为文件路径。
linux【网络编程】之HTTP协议
m0_54469145的博客
05-30 1344
本文讲解了应用层协议之HTTP协议，实验基于linux系统，以浏览器作为客户端，云服务器作为服务端，编码实现基于http的通信流程。。。
linux http协议
08-04
HTTP协议是一种应用层协议，它是基于TCP协议的。HTTP协议是一种无状态的...总之，Linux系统提供了丰富的工具和软件来支持HTTP协议的使用和开发。无论是进行HTTP请求还是搭建Web服务器，Linux都提供了相应的解决方案。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值