爱和冰阔落头像
【Linux网络】HTTP 请求到底长什么样?从 URL、请求响应报文到 Web 服务器完整实战封面图

【Linux网络】HTTP 请求到底长什么样?从 URL、请求响应报文到 Web 服务器完整实战

封面

🔥个人主页:爱和冰阔乐
📚专栏传送门:《数据结构与算法》 、C++、 《Linux操作系统》
🐶学习方向:C++方向学习爱好者
⭐人生格言:得知坦然 ,失之淡然

在这里插入图片描述


🏠博主简介
在这里插入图片描述


前言

上一部分已经把自定义应用层协议、序列化和反序列化走了一遍。HTTP 本质上仍然是一套应用层协议,只不过它已经把请求行、请求头、空行和正文的组织方式规定好了。本文先不急着写完整服务器,而是顺着一次浏览器访问,把 URL、请求报文、响应报文、Web 根目录和 URI 解析连起来。

文中的报文来自 Linux 5.15、GCC 11.4、C++17 环境下的本地回环测试:服务端返回 200,并且 Content-Length 与实际 HTML 正文字节数一致,后文会逐行对照。需要先明确:Content-Length 只统计消息正文,不统计状态行、响应头以及分隔头部与正文的空行。

本文实验环境与适用范围

项目本文使用环境
系统Linux 5.15 x86-64
编译器GCC 11.4
语言标准C++17
HTTP 客户端curl 7.81
测试方式回环地址上的 HTTP/1.1 请求
源码基线master / eff2eec7002e

本文先处理定长报文、URL、请求响应格式和静态资源映射,不实现分块传输、HTTPS、代理缓存与 HTTP/2 二进制帧。先把 HTTP/1.1 的基本报文边界走通,再扩展后续能力。

一、HTTP 在网络通信中负责什么

应用层协议可以由程序员自己约定,但浏览器和 Web 服务器要想直接通信,就必须遵守一套双方都认识的规则。HTTP(HyperText Transfer Protocol,超文本传输协议)就是最常用的应用层协议之一。

这里的“超文本”不只是普通文字。HTML 页面可以继续引用图片、CSS、JavaScript、音频和视频,因此浏览器打开一个页面时,往往会连续请求多个资源。HTTP 负责规定这些请求和响应应该怎样组织,至于数据最终通过网络送出去,仍然要依靠下层的 TCP/IP 协议栈。

浏览器先按照 HTTP 格式构造请求,服务器解析请求后找到资源,再按 HTTP 格式返回响应。HTTP 是无状态协议,意思是协议本身不会自动记住上一次请求中的用户身份;它不等于“每次请求都必须重新建立 TCP 连接”。HTTP/1.1 可以复用连接,后文会单独讨论长连接。

1.1 超文本、资源与 B/S 模式

我们平时使用浏览器访问网站,属于典型的 B/S(Browser/Server)模式:浏览器负责发起请求和展示页面,服务器负责保存或生成资源并返回结果。

在新闻页面点击一条链接后,浏览器会读取链接中的地址,再向目标服务器发起新的 HTTP 请求。这个地址可能对应 HTML,也可能对应图片、视频或接口返回的数据。对服务器来说,它们都可以看成“可被访问的资源”。

HTTPS 可以先理解为“在 TLS 保护下传输 HTTP 报文”。本文先把 HTTP 报文本身讲清楚,HTTPS 的加密和证书验证放到后面的章节。

二、URL 如何定位网络资源

URL(Uniform Resource Locator,统一资源定位符)就是我们平时说的网址。它不是一整段没有规律的字符串,而是把协议、主机、端口、路径和查询参数组合在一起,用来说明“通过什么方式,到哪台主机上访问哪个资源”。

http://www.example.com:8080/news/index.html?keyword=linux&page=1
\___/  \_____________/ \__/ \______________/ \__________________/
协议        主机名       端口       资源路径             查询参数

2.1 域名、IP 与 DNS

网络通信最终要使用 IP 地址找到目标主机,但 IP 地址不方便记忆,也缺少表意能力。相比 123.21.15.63 这类数字,域名更适合人阅读和使用。

浏览器不能直接拿域名完成 IP 层通信,所以访问网站前通常要先进行 DNS 解析:把域名交给 DNS 系统,得到对应的 IP 地址,再与目标服务器建立连接。一个域名可能对应多个 IP,一个 IP 也可能承载多个站点,因此不能把“域名”和“某个固定 IP”简单画成永久的一一对应关系。

浏览器访问新闻页面

所以在命令行中执行 ping baidu.com 时,输出里会出现 DNS 解析得到的 IP 地址。不过 ping 使用的是 ICMP,它只能帮助我们观察解析和连通性,不能代替 HTTP 请求。
通过 ping 观察域名解析结果
浏览器搜索入口

2.2 协议、端口和资源路径

有了 IP 还不够,因为一台主机上可能同时运行 SSH、Web、数据库等多个服务。端口号负责区分这些服务。HTTP 的默认端口是 80,HTTPS 的默认端口是 443,SSH 常用 22;URL 没有显式写端口时,客户端会根据协议采用默认值。

Linux 中的 0~1023 属于特权端口,普通用户通常不能直接绑定。这不是因为这些端口一定已经被占用,而是内核对低端口设置了权限限制。

确定协议、主机和端口后,客户端已经知道该连接到哪个服务;路径继续说明要访问这个服务管理的哪个资源。例如:

/rain/a/20260928A02GR500

在本文的静态服务器中,路径最终会映射到 Linux 文件;但在完整 Web 系统里,资源也可能由程序临时生成,或者来自数据库。URL 定位的是资源,不一定等于服务器磁盘上的原始文件路径。

从网络程序的角度看,下载页面、图片和视频属于从远端读取数据,登录、注册和提交表单属于向远端写入数据,本质上仍然是 I/O。HTTP 只是在 TCP 字节流之上进一步规定了数据的格式和语义。

2.3 查询参数与 URL 编码

URL 中还可以携带查询参数。
URL 各部分含义

我们在搜索引擎中输入 hello://@ world 后,地址栏会出现一串很长的查询参数,其中真正与搜索词对应的是 wd=hello%EF%BC%9A%2F%2F%40%20world。其他字段由搜索页面自己使用,这里只关注参数编码。

搜索内容经过 URL 编码后的地址

查询字符串通常写成 key=value,多个参数之间使用 & 分隔,而不是 &&:

?keyword=linux&page=1

/、?、&、= 等字符在 URL 中有自己的语法作用。如果参数值本身包含这些字符,就不能直接拼进去,需要先做百分号编码。编码时按字符的字节序列逐字节转换,每个字节写成 %HH。例如 + 对应 %2B,空格常见为 %20。

搜索 hello://@ world 时,浏览器把特殊字符和空格编码后再放入查询参数:
包含查询参数的搜索地址
服务器收到参数后再进行 URL Decode,才能还原原始内容。编码和解码必须以相同的字符集为基础,否则中文等多字节字符会被错误解释。

静态资源和动态资源的区别也不在于 URL 中有没有参数。静态资源通常可以直接读取文件返回;动态响应则需要服务器根据参数、用户状态或数据库内容现场生成。两者都可以使用 GET,也都可能出现在带查询参数的 URL 中。

三、HTTP 请求与响应的基本结构

HTTP 用起始行、头部、空行和可选正文组织数据;空行不是排版,而是报头与正文的边界。

有了url和编码的认识,我们来看下HTTP的请求。HTTP协议是在应用层的,底层采用的协议是tcp协议。HTTP请求也是一种协议,HTTP协议必须是结构化的信息。

3.1 请求报文

HTTP请求:
浏览器提交的 HTTP 请求报文

截图底部的空行不是为了美观,它负责分隔报头和正文。空行上面是请求行与请求头,下面是可选的请求正文。

请求报文可以拆成四部分:

  • 请求行:方法 URI HTTP版本;
  • 请求头:若干 Key: Value,每行以 \r\n 结束;
  • 空行:一个单独的 \r\n,表示请求头结束;
  • 请求正文:可选。如果存在正文,通常需要 Content-Length 或分块编码说明边界。

HTTP 请求报文结构
从传输层看,HTTP 报文就是一段字节流;从应用层看,它又是有明确结构的数据。客户端把方法、URI、版本、头部和正文拼成报文,这是序列化;服务器按同样的规则拆开报文,这是反序列化。

这里要区分两个边界:

  1. \r\n\r\n 只能确定报头结束;
  2. 如果存在正文,还要继续读取 Content-Length 指定的字节数,才能得到完整请求。

3.2 响应报文

HTTP 响应报文结构

响应报文同样分成状态行、响应头、空行和响应正文。正文可以是 HTML、CSS、JavaScript、图片、音视频,也可以是 JSON 等接口数据。

状态行一般写成:

HTTP/1.1 200 OK

HTTP/1.1 是协议版本,200 是状态码,OK 是原因短语。浏览器真正判断结果时主要看状态码,原因短语更多是给人阅读。

基本的应答格式
浏览器开发者工具中的响应报文
请求和响应的整体框架相似,但起始行含义不同:请求行说明“我要怎样访问哪个资源”,状态行说明“服务器处理得怎么样”。空行之后才是正文。

四、方法、版本与响应序列化

HTTP 方法表示客户端希望对资源执行什么操作。

4.1 先认识 GET 与 POST

最常见的是 GET 和 POST。GET 通常用于获取资源,参数可以出现在 URI 的查询字符串中;POST 通常把待提交的数据放在请求正文中。方法只是语义约定,服务器仍要根据路由和业务逻辑决定怎样处理。

4.2 服务器怎样构造响应

HttpResponse resp;
resp._version = "HTTP/1.1";
resp._code = 200;
resp._desc = "OK";
resp._headers["Content-Type"] = "text/html";
resp._text = "<html><body><h1>Hello World</h1></body></html>";
resp._headers["Content-Length"] = std::to_string(resp._text.size());

服务器准备好状态、响应头和正文后,还要把结构化数据序列化成字节流。浏览器收到 Content-Type: text/html 后,才会把正文按 HTML 解析和展示。

std::string Serialize() const
{
    std::string response;
    response += _version + " " + std::to_string(_code) + " " + _desc + "\r\n";

    for (const auto& [key, value] : _headers)
    {
        response += key + ": " + value + "\r\n";
    }

    response += "\r\n";
    response += _text;
    return response;
}

序列化本身就是按协议顺序拼接字符串。真正容易出错的是边界:状态行和每个头部后面都是 \r\n,头部结束还要再补一个空行,同时 Content-Length 必须等于正文的字节数。

五、Web 根目录与 URI 解析

URI 描述客户端想访问的资源,Web 根目录决定服务器到哪里寻找该资源。两者不能直接画等号。

URL 中主机名后面的 / 是 URI 路径的起点,但它不是服务器 Linux 文件系统的根目录。服务器需要自己指定一个 Web 根目录,再把 URI 映射到这个目录中。

浏览器发送的请求头
在请求行 GET / HTTP/1.1 中,/ 表示站点首页。服务器通常把它映射为 Web 根目录中的 index.html。

通过 URI 请求指定资源

如果地址栏访问 /a/b/c.html,浏览器会把这段路径写入请求行。服务器解析出 URI 后,再决定它对应哪个本地文件或业务处理函数;如果地址栏没有继续写路径,默认 URI 就是 /。
服务器返回静态页面
请求 URI 中的 / 不是 Linux 根目录。 Web 根目录是服务器配置出来的资源目录,例如项目中的 ./wwwroot。首页也不是把整个目录返回给浏览器,而是把 / 映射为约定的 index.html。

把 HTML 硬编码在 C++ 字符串里只能用于最初测试。静态服务器更合理的做法是把页面、图片、CSS 和 JavaScript 放在 Web 根目录中,根据 URI 读取对应文件。

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

std::string uri = request._uri;
std::string filename = (uri == "/")
    ? webroot + "/" + homepage
    : webroot + uri;

if (!Util::ReadFileContent(filename, &resp._text))
{
    resp._code = 404;
    resp._desc = "Not Found";
}

例如 URI 是 /a/b/c.html,映射结果就是 ./wwwroot/a/b/c.html;URI 是 /,映射结果就是 ./wwwroot/index.html。不过在真正拼接前必须检查 .. 等路径穿越内容,否则客户端可能借助 URI 逃出 Web 根目录。

5.1 方法、URI 与版本分别说明什么

请求行只有三个字段,但三个字段各有作用:

  • 方法:说明希望怎样操作资源,例如 GET、POST、HEAD;
  • URI:说明希望访问哪个资源;
  • 版本:说明客户端按哪个 HTTP 版本组织和解释报文。

响应状态行也会携带版本,因为服务器同样要说明自己按哪套 HTTP 规则返回结果。版本字段解决的是协议兼容问题,不是浏览器或服务器应用程序自身的版本号。

5.2 TCP 字节流下如何确认完整报文

TCP 面向字节流,一次 recv 可能只拿到半个请求,也可能同时拿到后续数据。服务器不能把“本次 recv 返回了多少字节”当成 HTTP 报文边界。

正确顺序是:

  1. 循环接收,直到缓冲区出现 \r\n\r\n;
  2. 解析请求头,取得 Content-Length;
  3. 如果正文还没收完整,继续读取;
  4. 最后再把完整报文交给反序列化逻辑。
bool RecvHttpRequest(int sockfd, std::string* request)
{
    char buffer[4096];
    std::size_t headerEnd = std::string::npos;
    std::size_t contentLength = 0;

    while (true)
    {
        ssize_t n = recv(sockfd, buffer, sizeof(buffer), 0);
        if (n <= 0) return false;
        request->append(buffer, static_cast<std::size_t>(n));

        if (headerEnd == std::string::npos)
        {
            headerEnd = request->find("\r\n\r\n");
            if (headerEnd == std::string::npos) continue;

            std::string headers = request->substr(0, headerEnd + 2);
            std::string key = "Content-Length:";
            auto pos = headers.find(key);
            if (pos != std::string::npos)
            {
                pos += key.size();
                contentLength = std::stoul(headers.substr(pos));
            }
        }

        const std::size_t bodyStart = headerEnd + 4;
        if (request->size() >= bodyStart + contentLength) return true;
    }
}

这段代码只展示本文需要的核心边界判断,还没有处理分块传输、报文大小限制和超时。它的重点是说明:完整 HTTP 请求必须由协议字段判断,不能靠一次 recv 猜。

5.3 反序列化请求行并映射资源

bool Deserialize(std::string &request)
{
    std::string request_line;
    if (!Util::ReadOneLine(request, &request_line, "\r\n"))
        return false;

    std::stringstream line_stream(request_line);
    if (!(line_stream >> _method >> _uri >> _version))
        return false;

    std::string line;
    while (Util::ReadOneLine(request, &line, "\r\n") && !line.empty())
    {
        auto pos = line.find(':');
        if (pos == std::string::npos)
            return false;

        std::string key = line.substr(0, pos);
        std::string value = line.substr(pos + 1);
        while (!value.empty() && value.front() == ' ')
            value.erase(value.begin());
        _headers[key] = value;
    }

    // 先拆查询参数,再将 URI 映射到 Web 根目录。
    auto query_pos = _uri.find('?');
    if (query_pos != std::string::npos)
    {
        _args = _uri.substr(query_pos + 1);
        _uri.resize(query_pos);
        _is_interact = true;
    }

    if (_uri.find("..") != std::string::npos)
        return false;

    _uri = (_uri == "/") ? webroot + "/" + homepage : webroot + _uri;
    return true;
}

经过这一步,服务器才能知道客户端请求了哪个资源。为了让主线更清楚,这里把查询参数和路径放在同一个结构中演示;完整代码中更适合分别保存原始 URI、路径和查询字符串,避免后续业务处理混淆。

5.4 页面跳转仍然是一次新请求

网页中的 <a> 标签只负责告诉浏览器目标地址。用户点击后,浏览器读取 href,再对目标地址发起新的 HTTP 请求。服务器并不是把“跳转动作”发送给显示器,而是返回新资源,最终由浏览器更新页面。
开发者工具中的资源请求

六、用真实请求核对报文结构

修正后的服务器在 Linux 5.15、GCC 11.4、C++17 环境下编译,并只监听回环地址。启动服务后执行:

curl --noproxy '*' -v http://127.0.0.1:18085/ -o /dev/null

客户端实际发出的请求行和请求头如下:

> GET / HTTP/1.1
> Host: 127.0.0.1:18085
> User-Agent: curl/7.81.0
> Accept: */*

服务器返回:

< HTTP/1.1 200 OK
< Set-Cookie: username=zhangsan;
< Content-Length: 2913
< Content-Type: text/html

这组报文正好对应前面的结构:GET / HTTP/1.1 是请求行,后面是请求头;HTTP/1.1 200 OK 是状态行,后面是响应头。空行之后才是 2913 字节的 HTML 正文。换句话说,Content-Length: 2913 表示消息体恰好有 2913 字节,状态行、响应头和空行均不计入该值。这里没有把终端输出画成图片,保留文本更方便读者逐行核对。

再把验证结果和前面的推导对应起来:

观察到的字段它解决的问题
GET / HTTP/1.1方法、目标资源和协议版本
Host: 127.0.0.1:18085目标站点及端口
HTTP/1.1 200 OK本次请求处理成功
Content-Type: text/html正文应按 HTML 解释
Content-Length: 2913仅消息正文为 2913 字节,不含状态行、响应头和空行

因此,一次 HTTP 访问不是“浏览器凭感觉读取页面”,而是请求端和响应端都严格按字段解释同一段字节流。只要状态行、头部、空行或正文长度有一处不一致,浏览器就可能等待、截断或错误解析。

6.1 从输入 URL 到显示页面,完整链路是什么

把前面分散的概念连起来,一次最基本的页面访问会经过下面几步:

  1. 浏览器拆分 URL,得到协议、主机、端口、路径和查询参数;
  2. 如果主机是域名,先通过 DNS 得到可用 IP;
  3. 浏览器与目标 IP、端口建立 TCP 连接;
  4. 浏览器把方法、URI、版本和请求头序列化为 HTTP 请求;
  5. 服务器按 \r\n\r\n 与 Content-Length 接收完整报文,再完成反序列化;
  6. 服务器把 URI 映射到静态文件或业务处理函数,构造状态码、响应头和正文;
  7. 浏览器根据 Content-Type 解释正文,并继续请求页面引用的其他资源。

这条链路中,URL 解决“访问谁、访问什么”,TCP 解决“字节怎样可靠送达”,HTTP 解决“这些字节各自表示什么”。三者职责不同,但在一次网页访问中又必须连续配合。

6.2 当前实现的边界

本文代码是为了把 HTTP 报文结构跑通,不是一个生产级 Web 服务器。当前实现只处理本文用到的 HTTP/1.0、HTTP/1.1 请求和 Content-Length 定长正文,还没有实现下面这些能力:

  • Transfer-Encoding: chunked 分块传输;
  • 报文头和正文的最大长度限制;
  • 读取超时、慢连接防护和并发连接管理;
  • 完整的 URI 解码、规范化与权限检查;
  • HTTPS 握手、证书验证与加密传输。

明确这些边界不是给代码“找补”,而是避免把教学版本误认为完整实现。后续文章会继续补静态资源、状态码、重定向、GET/POST 以及连接管理。

6.3 完整源码与复现入口

本文使用的工程不是只截取几段示意代码。完整目录中包含 Http.hpp、Socket.hpp、TcpServer.hpp、Util.hpp、Main.cc、makefile 和 wwwroot 静态资源目录:

http协议_应用层/
├── Http.hpp
├── Socket.hpp
├── TcpServer.hpp
├── Util.hpp
├── Main.cc
├── makefile
└── wwwroot/
    ├── index.html
    ├── 404.html
    └── image/

源码基线固定为 master 分支提交 eff2eec7002e04bcf2bf7bb4ac40975c64062db2:Gitee:HTTP 协议应用层示例(固定提交)。本文展示的修正版重点是报文边界、二进制读取、完整发送和非法路径检查,复现时还要应用文章明确列出的修正。

七、初学 HTTP 服务器最容易写错的地方

7.1 把一次 recv 当成完整请求

TCP 没有 HTTP 报文边界。一次读取可能只得到半个报头,也可能已经带上正文。必须先找到 \r\n\r\n,再按正文长度继续接收。

7.2 把 URI 直接拼到文件系统根目录

URI 是客户端输入,必须先拆查询参数、URL 解码并检查路径穿越。发现 .. 不能继续读取,更稳妥的实现还要规范化路径并确认最终结果仍位于 Web 根目录内。

7.3 用字符数代替字节数

Content-Length 计算的是正文传输字节数。UTF-8 中文可能占多个字节,不能用“屏幕上有多少个字符”估算。

7.4 忘记响应头与正文之间的空行

最后一个响应头后面必须再写一个 \r\n。缺少空行时,浏览器可能把正文开头继续当成响应头解析。

7.5 只设置 Content-Length,不设置 Content-Type

长度解决正文边界,类型解决解释方式。两者互不替代,返回 PNG、CSS、JavaScript 时必须匹配实际资源类型。

总结

  • URL 负责定位资源,协议、主机、端口、路径和查询参数各自承担不同作用。
  • HTTP 请求和响应都由起始行、若干头部、空行以及可选正文组成。
  • TCP 只提供字节流,服务器仍要依靠 \r\n\r\n 和 Content-Length 判断报文边界。
  • URI 不能直接当成本地路径使用,映射到 Web 根目录前必须检查非法路径。
  • Content-Type 决定正文如何解释,Content-Length 决定正文在哪里结束,两者作用不同。

参考资料

往期博客分享
【Linux网络】JsonCpp 怎么实现序列化?从 Request/Response 到网络计算器消息设计
【Linux网络】TCP 半包粘包怎么解决?从长度报头、JSON 拆包到网络计算器完整实战
【Linux】守护进程怎么实现?从进程组、会话到 setsid 与 Daemon 完整实战

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/2402_87731470/article/details/171112653

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--