C++ 网络编程知识点详解

// muduo 风格 echo server（简化示意）
#include <muduo/net/TcpServer.h>
#include <muduo/net/EventLoop.h>
using namespace muduo;
using namespace muduo::net;

void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp t) {
    conn->send(buf);  // 原样回显
}

int main() {
    EventLoop loop;
    InetAddress listenAddr(8888);
    TcpServer server(&loop, listenAddr, "echo");
    server.setMessageCallback(onMessage);
    server.setThreadNum(4);   // one loop per thread
    server.start();
    loop.loop();
    return 0;
}

#include <soci/soci.h>
#include <soci/sqlite3/soci-sqlite3.h>
#include <iostream>
#include <string>

int main() {
    soci::session sql(soci::sqlite3, "test.db");
    sql << "CREATE TABLE IF NOT EXISTS users(id INT, name TEXT)";
    sql << "INSERT INTO users VALUES(1, 'alice')";

    std::string name;
    // into 自动绑定并取值，异常由 soci_error 统一捕获
    sql << "SELECT name FROM users WHERE id = :id", soci::use(1), soci::into(name);
    std::cout << name << std::endl;  // alice
    return 0;
}

#include <spdlog/spdlog.h>
#include <spdlog/sinks/rotating_file_sink.h>
#include <spdlog/async.h>

int main() {
    // 异步日志 + 滚动文件（5MB x 3 个）
    auto logger = spdlog::rotating_logger_mt<spdlog::async_factory>(
        "app", "logs/app.log", 1024 * 1024 * 5, 3);
    spdlog::set_default_logger(logger);
    spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%l] %v");

    spdlog::info("用户 {} 登录，IP={}", "alice", "10.0.0.1");
    spdlog::error("请求处理失败，code={}", 500);
    return 0;
}

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>

int add(int a, int b) { return a + b; }

TEST_CASE("加法正确", "[math]") {
    REQUIRE(add(1, 2) == 3);      // 失败时打印两侧实际值
    REQUIRE(add(0, 0) == 0);
}

#include <sys/epoll.h>
#include <unistd.h>

int epfd = epoll_create1(0);          // 创建 epoll 实例
struct epoll_event ev{}, events[64];

ev.events = EPOLLIN | EPOLLET;        // ET 模式监听读事件
ev.data.fd = listen_fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);  // 注册到红黑树

for (;;) {
    int n = epoll_wait(epfd, events, 64, -1);     // 只返回就绪 fd
    for (int i = 0; i < n; ++i) {
        if (events[i].data.fd == listen_fd) {
            // accept 新连接（ET 下要循环 accept 直到 EAGAIN）
        } else {
            // 处理已就绪的读写事件
        }
    }
}

#include <sys/epoll.h>
#include <unistd.h>

// Reactor：epoll 监听就绪事件，用户代码同步 read
void handle_read(int fd) {
    char buf[1024];
    ssize_t n = read(fd, buf, sizeof(buf));  // 此刻 fd 已就绪，同步读取
    if (n > 0) { /* 处理 buf */ }
}

#include <sys/sendfile.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

// sendfile：内核内完成「文件 → socket」的传输，不经过用户态
int in_fd = open("file.bin", O_RDONLY);
struct stat st;
fstat(in_fd, &st);
off_t offset = 0;
ssize_t sent = sendfile(sock_fd, in_fd, &offset, st.st_size);  // 直接发送

#include <cstdint>
#include <cstring>
#include <vector>
#include <arpa/inet.h>

struct Header { uint32_t body_len; };  // 网络字节序

// 编码：包头（4 字节长度）+ 包体
std::vector<char> encode(const std::string& body) {
    Header h;
    h.body_len = htonl(body.size());
    std::vector<char> out(sizeof(h) + body.size());
    memcpy(out.data(), &h, sizeof(h));
    memcpy(out.data() + sizeof(h), body.data(), body.size());
    return out;
}

// 解码：接收端维护累积缓冲区，先读满 4 字节头，再按长度读满 body
// while (buf.size() >= 4) {
//     uint32_t len = ntohl(*(uint32_t*)buf.data());
//     if (buf.size() < 4 + len) break;   // 半包，等待下次数据到达
//     取出 [4, 4 + len) 为一条完整消息；buf 左移继续解析
// }

TCP 连接的构成
─────────────────────────────────────────────────────────
  客户端内核                          服务端内核
  ┌─────────────────┐               ┌─────────────────┐
  │ 源IP:源端口      │               │ 目的IP:目的端口   │
  │ 目的IP:目的端口  │               │ 源IP:源端口      │
  │ seq / ack       │◄── 状态同步 ──►│ seq / ack       │
  │ 窗口 / 拥塞窗口  │   (三次握手)   │ 窗口 / 拥塞窗口  │
  │ 状态机(11 种)   │               │ 状态机(11 种)    │
  └─────────────────┘               └─────────────────┘
       逻辑连接 = 四元组 + 两端状态，无物理独占信道
─────────────────────────────────────────────────────────

一条连接唯一由四元组标识：
  { 源IP, 源端口, 目的IP, 目的端口 }

服务端监听 80 端口时：
  目的IP、目的端口固定
  源IP 有 2^32 种，源端口 2^16 种
  → 理论组合 ≈ 2^48，远超 65535

        TCP（字节流）                 UDP（数据报）
  发送 3 次 send                    发送 3 次 sendto
  ─────────────►  合并/拆分          ─────────────►  独立成包
  接收端看到连续字节，无边界          接收端 3 次 recvfrom，各得一个完整包
  → 有粘包/拆包问题                  → 天然有边界，无粘包问题

端到端原则：
  可靠性应由「端系统」保证，网络层保持「尽力而为、无状态」

  若 IP 层强制可靠：
  每个路由器都要为每条流维护状态、缓存重传
  → 路由器要存储海量连接状态，转发性能崩、扩展性崩
  → 且应用需求千差万别（实时性 vs 可靠性），一刀切不可行

  正确分层：
  应用层 ──► 想要什么语义自己选
  传输层 ──► TCP(可靠) / UDP(轻量)，端到端实现
  网络层 ──► IP：简单、无状态、尽力转发

       客户端                              服务端
   CLOSED                                LISTEN
     │ ① SYN, seq=x                        │
     │────────────────────────────────────►│ 收到后进入 SYN_RECV
     │                                     │
     │ ② SYN+ACK, seq=y, ack=x+1          │
     │◄────────────────────────────────────│
     │                                     │
     │ ③ ACK, seq=x+1, ack=y+1            │
     │────────────────────────────────────►│
   ESTABLISHED                           ESTABLISHED

ISN 生成思路（Linux）：
  ISN = 单调递增的时间分量(每 4μs +1，RFC793)
        + 随机偏移(基于源/目的 IP、端口、密钥的 hash)
  → 结果既随时间单调、又难以被外部预测

客户端发 SYN 后宕机：
  客户端                    服务端
    │ ① SYN                   │
    │──────────►              │ 进入 SYN_RECV
    │ ② SYN+ACK              │
    │◄──────────              │ 未收到 ACK，按指数退避重传 SYN+ACK
    │  (宕机，无 ACK)          │ 1s → 2s → 4s → 8s → 16s → 32s
    │                         │ 重传 tcp_synack_retries 次(默认5)后放弃
    │                         │ → 回收连接，回到 LISTEN

攻击者                          服务端
 伪造源IP的 SYN ─────────────►  每收到一个 SYN 就：
                                1) 分配半连接条目
                                2) 回 SYN+ACK（发往伪造的源IP，无人回应）
                                3) 进入 SYN_RECV，等待 ACK
  大量伪造 SYN ─────────────►   半连接队列被打满
                                正常用户的 SYN 被丢弃 → 服务不可用

可靠传输核心闭环：
  发送方                   接收方
  发 seq=100~199           收到后回 ack=200（表示 200 之前已按序收到）
     │── 数据 ──►          若有乱序，暂存并按 seq 排序
     │◄── ack=200          重复/损坏/失序按规则丢弃或缓存
  超时或 3 个重复 ACK → 重传

   主动方                                    被动方
 ESTABLISHED                              ESTABLISHED
    │ ① FIN, seq=u（我不再发数据）            │
    │──────────────────────────────────────►│ 进入 CLOSE_WAIT
    │ ② ACK, ack=u+1                        │（可能还有数据要发）
    │◄──────────────────────────────────────│
    │ 进入 FIN_WAIT_2，等待对方 FIN          │
    │ ③ FIN, seq=w, ack=u+1                 │（数据发完，也关闭发送）
    │◄──────────────────────────────────────│
    │ ④ ACK, ack=w+1                        │
    │──────────────────────────────────────►│
  TIME_WAIT（等 2MSL）                     LAST_ACK → CLOSED

原因一：保证最后一个 ACK 可靠送达
  主动方发 ④ACK 后直接关，若 ACK 丢失，被动方会重传 FIN
  → 主动方必须保留状态，能再次回应 ACK
  → 否则被动方会一直 LAST_ACK 重传、无法正常关闭

原因二：让旧连接的迟到报文在网络中消亡
  2MSL = 一个报文去 + 一个报文回的最大时间
  → 保证本连接所有残留在网络里的报文都已消失
  → 防止「旧连接的迟到报文」被复用同四元组的新连接误收

两种关闭方式对比：
  FIN（正常关闭）              RST（异常关闭）
  ────────────────            ────────────────
  四次挥手，优雅关闭           单报文，立即断开
  保证数据可靠交付完            丢弃发送/接收缓冲中未处理数据
  主动方进入 TIME_WAIT        主动方直接 CLOSED，不进入 TIME_WAIT
  对端收到后进入 CLOSE_WAIT    对端收到后直接复位

RTT 测量 -> 平滑往返时间 SRTT
SRTT = (1-α)·SRTT + α·RTT           （α 常取 1/8）
RTTVAR = (1-β)·RTTVAR + β·|SRTT - RTT|   （β 常取 1/4）
RTO = SRTT + 4·RTTVAR                 （保证留有余量）

正常关闭：  A --FIN--> B --ACK--> A --FIN--> B --ACK--> A   （四次挥手）
异常重置：  A --RST--> B   （B 收到后立即关闭，无需 ACK）

发送方发 [1][2][3][4][5]，其中 [2] 丢失：

接收方收到 [1]  -> ACK 2          （期望 2）
接收方收到 [3]  -> 重复 ACK 2     （乱序，重发对 [1] 的确认）
接收方收到 [4]  -> 重复 ACK 2     （第 2 个重复 ACK）
接收方收到 [5]  -> 重复 ACK 2     （第 3 个重复 ACK）

发送方收到 3 个重复 ACK 2 -> 立刻重传 [2]，无需等待 RTO

没有 SACK：发送方收到 3 个重复 ACK，只知道「有个段丢了」，
           可能把整个窗口的段都重传一遍。

有 SACK：  接收方 ACK 里附带「已收到 [1001,1500)、[2001,2500)」，
           发送方精准知道缺 [1501,2000]，只重传这一个洞。

TCP SACK 选项（示意）：
+--------+--------+----------------+
| Kind=5 | Length | Left Edge ...  |
+--------+--------+----------------+
|   Right Edge ...  （可多个块）   |
+----------------------------------+

发送方视角（字节流）：
|<-- 已确认 -->|<------ 已发送未确认 ------>|<-- 可继续发送 -->|<-- 不可发送 -->|
               ^ 窗口左沿                   ^ 窗口右沿
               |<---------- 发送窗口 --------->|  （受 rwnd 与 cwnd 共同约束）

rwnd = 4096，已发送未确认 2048 -> 还能发 2048
接收方处理后通告 rwnd = 8192 -> 窗口右移，可继续发更多

cwnd
  ^
  |         *   *   *   *    <- 拥塞避免：线性增长
  |      *
  |    *
  |  *                        <- 慢启动：指数增长
  | *
  +--------------------------> 时间
       ssthresh 阈值处切换

ARP：  A 要发给 IP=192.168.1.2，但不知其 MAC
      -> 广播 ARP 请求「谁是 192.168.1.2？告诉我你的 MAC」
      -> 目标机单播应答「我是，我的 MAC 是 xx:xx:xx:xx:xx:xx」
      -> A 把 IP-MAC 映射写入 ARP 缓存

RARP： 无盘机只知道自己的 MAC
      -> 广播 RARP 请求「我是 xx:xx:xx:xx:xx:xx，我的 IP 是多少？」
      -> RARP 服务器应答「你的 IP 是 192.168.1.5」

+------------------+
|     应用层        |  HTTP / DNS / FTP ...
+------------------+
|     传输层        |  TCP / UDP（端口，端到端）
+------------------+
|     网络层        |  IP（IP 地址，路由转发）
+------------------+
|   网络接口层      |  以太网 / WiFi（MAC 地址，帧）
+------------------+

应用层数据
   -> + TCP 头   = 段（Segment）
   -> + IP 头    = 包（Packet）
   -> + 帧头/尾  = 帧（Frame）

7 应用层      <-- 人机交互
6 表示层      <-- 加解密、编码
5 会话层      <-- 会话管理
4 传输层      <-- 端到端（TCP/UDP）
3 网络层      <-- IP 路由
2 数据链路层  <-- MAC 帧
1 物理层      <-- 比特/信号

Cookie + Session 模式（传统，有状态）：
  登录 -> 服务端生成 session_id -> 存服务端 -> 通过 Set-Cookie 下发
  之后每次请求 -> 浏览器自动带 Cookie(session_id) -> 服务端查 Session

Token 模式（无状态，如 JWT）：
  登录 -> 服务端签发 Token（含用户信息+签名）-> 返回客户端
  之后每次请求 -> 客户端手动在 Header 带 Token -> 服务端验签即可

Header.Payload.Signature

Header    = base64url({ "alg": "HS256", "typ": "JWT" })
Payload   = base64url({ "sub": "10086", "name": "alice", "exp": 1720000000 })
Signature = HMACSHA256( base64url(Header) + "." + base64url(Payload), secret )

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMDA4NiJ9.签名部分
  ^ Header          ^ Payload        ^ Signature

// JWT 使用思路（伪代码，仅示意流程）
std::string token = jwt::create()
    .set_issuer("myapp")
    .set_subject("10086")
    .set_expires_at(std::chrono::system_clock::now() + std::chrono::hours(2))
    .sign(jwt::algorithm::hs256{"secret"});   // 签发

auto decoded = jwt::decode(token);            // 校验并解析
auto verifier = jwt::verify().allow_algorithm(jwt::algorithm::hs256{"secret"});
verifier.verify(decoded);                     // 验签，失败则拒绝

.                       根域名服务器（Root，全球 13 组）
└── com                 顶级域 TLD（.com/.org/.cn ...）
    └── baidu.com       二级域（权威服务器）
        └── www         主机名

客户端 -> 本地 DNS 服务器（递归查询，本地帮你查到底）
本地 DNS -> 根服务器（问 .com 在哪）          -> 返回 .com 服务器
         -> .com 服务器（问 baidu.com 在哪）  -> 返回 baidu.com 权威服务器
         -> baidu.com 权威服务器（www 的 IP？）-> 返回最终 IP
         -> 缓存结果并返回给客户端

                 +-----------+
  用户A(北京) -->| 边缘节点  |\
                 +-----+-----+ \
                       |        \   未命中则回源
  用户B(上海) -->+-----+-----+   +---------+
                 | 边缘节点  |---| 源站(源)|
                 +-----------+   +---------+
   就近访问 -> 命中缓存直接返回，不绕远路到源站

1. URL 解析/浏览器缓存 -> 判断协议(https)、域名、路径、是否命中浏览器/系统缓存
2. DNS 解析            -> 域名 -> IP（本地缓存 -> 递归 -> 根/TLD/权威）
3. TCP 三次握手        -> SYN -> SYN+ACK -> ACK，建立可靠连接
4. TLS 握手（HTTPS）   -> 协商加密套件、校验证书、交换密钥
5. 发送 HTTP 请求      -> GET /page HTTP/1.1 + 各种 Header
6. 服务器处理并响应     -> HTTP 响应（状态码 + 响应头 + 正文）
7. 浏览器接收并渲染     -> 解析 HTML -> 构建 DOM/CSSOM -> 布局 -> 绘制
8. 连接复用/关闭        -> keep-alive 复用，或四次挥手关闭

Session 模式：   登录 -> 服务端存 Session -> 下发 session_id(Cookie)
                 请求 -> 带 Cookie -> 服务端查 Session -> 判身份

JWT 模式：       登录 -> 服务端签 JWT -> 客户端自持
                 请求 -> Header 带 Token -> 服务端验签 -> 判身份

OAuth 模式：     用户 -> 同意授权 -> 第三方发 code -> 换 token -> 访问资源

HTTP/1.0（串行，一条请求一个连接）
连接1: [请求A] [响应A] ── 关闭
连接2: [请求B] [响应B] ── 关闭
        ↑ 每次都要 TCP 三次握手，资源开销大

HTTP/2（单连接多路复用）
连接:  Stream1 ─ [HEADERS][DATA]──响应A
       Stream2 ─ [HEADERS][DATA]──响应B   ← 多流交织在同一 TCP 连接
       Stream3 ─ [HEADERS][DATA]──响应C
       帧可交错，靠 Stream ID 区分归属

HTTP/2（TCP + TLS，需要多轮握手）
客户端          服务端
  │── TCP SYN ──→│
  │←─ SYN+ACK ──│    ① TCP 三次握手（1 RTT）
  │── ACK ─────→│
  │── ClientHello →│  ② TLS 握手（1~2 RTT）
  │←─ ServerHello ─│
  合计约 2~3 RTT 才能发出第一个 HTTP 请求

HTTP/3（QUIC，握手与 TLS 合并，支持 0-RTT）
客户端          服务端
  │─ Initial(CHLO+密钥) →│  ① 1-RTT 即建立连接并加密
  │─ 0-RTT 数据直接发出 →│  ② 复用会话时首个请求可 0-RTT 发送

1xx  信息响应：请求已收到，继续处理
2xx  成功：请求被成功接收、理解、处理
3xx  重定向：需要进一步操作才能完成请求
4xx  客户端错误：请求有语法错误或无法完成（错在客户端）
5xx  服务端错误：服务器处理请求失败（错在服务端）

POST /api/user HTTP/1.1        ← 请求行：方法 路径 版本
Host: www.example.com           ← 请求头（若干行 key: value）
Content-Type: application/json
Content-Length: 27

{"name": "alice", "age": 20}   ← 请求体（可有可无）

客户端                         服务端
  │──── ClientHello ────────────→│   ① 客户端给出支持的加密套件/随机数
  │←── ServerHello + 证书 ──────│   ② 服务端选套件、发证书与随机数
  │←── ServerKeyExchange/Finished│
  │── 校验证书 + 生成预主密钥 ───→│   ③ 双方算出会话密钥（对称）
  │──── Finished（加密生效）────→│
  │⇄═════ 之后的 HTTP 报文全部对称加密传输 ═════⇄

GET /api/user?id=123&name=alice HTTP/1.1     ← 参数在 URL，明文可见
Host: www.example.com

POST /api/user HTTP/1.1                       ← 参数在 body
Host: www.example.com
Content-Type: application/json
Content-Length: 27

{"id": 123, "name": "alice"}

客户端                                   服务端
  │── GET /chat HTTP/1.1 ──────────────→│
  │   Host: example.com                  │
  │   Upgrade: websocket                 │  ① 客户端申请升级
  │   Connection: Upgrade                │
  │   Sec-WebSocket-Key: xxx(base64)     │
  │←── HTTP/1.1 101 Switching Protocols ─│  ② 服务端同意升级
  │   Sec-WebSocket-Accept: yyy          │
  │⇄══════ 之后切换为 WebSocket 帧双向通信 ══════⇄

accept 新连接 → 注册到 epoll 监听可读
       ↓ epoll 通知可读
read 数据追加进「接收缓冲区」
       ↓
在缓冲区中查找 "\r\n\r\n" 定界头部
       ↓（未找到 → 半包，继续等下一次 read）
解析请求行：方法、路径、版本
解析请求头：逐个 "Key: Value" 行
       ↓
按 Content-Length 或 Transfer-Encoding: chunked 确定 body 长度
       ↓（body 没读满 → 继续缓存等待）
取出完整 body → 交给业务处理（Router/Handler）
       ↓
按 Keep-Alive 决定是否继续在同一连接解析下一条请求

#include <string>
#include <string_view>

// 简化示意：从累积缓冲区中切出一条完整 HTTP 请求
// 返回 true 表示已切出一条完整请求并填入 req；否则数据未到齐（半包）
bool parse_request(std::string& buf, std::string& req) {
    auto header_end = buf.find("\r\n\r\n");      // 头部与 body 的分界
    if (header_end == std::string::npos) {
        return false;                             // 头部还没收全，等下一次 read
    }
    // 解析头部中的 Content-Length
    size_t content_length = 0;
    std::string_view headers(buf.data(), header_end);
    if (auto pos = headers.find("Content-Length: "); pos != std::string_view::npos) {
        content_length = std::stoul(std::string(
            headers.substr(pos + 16)));           // 取出长度值
    }
    size_t total = header_end + 4 + content_length;
    if (buf.size() < total) {
        return false;                             // body 还没到齐（半包）
    }
    req = buf.substr(0, total);                   // 切出完整请求
    buf.erase(0, total);                          // 剩余字节留给下一条（粘包）
    return true;
}