• [SYN_RCVD -> ESTABLISHED] 服务端一旦收到客户端的确认报文, 就进入ESTABLISHED状态, 可以进行读写数据了；
• [ESTABLISHED -> CLOSE_WAIT] 当客户端主动关闭连接(调用close), 服务器会收到结束报文段, 服务器；
• 返回确认报文段并进入CLOSE_WAIT；
• [CLOSE_WAIT -> LAST_ACK] 进入CLOSE_WAIT后说明服务器准备关闭连接(需要处理完之前的数据); 当服务器真正调用close关闭连接时, 会向客户端发送FIN, 此时服务器进入LAST_ACK状态, 等待最后一个ACK到来(这个ACK是客户端确认收到了FIN)；
• [LAST_ACK -> CLOSED] 服务器收到了对FIN的ACK, 彻底关闭连接；

这是因为,虽然server的应用程序终止了,但TCP协议层的连接并没有完全断开,因此不能再次监 听同样的server端口；

#pragma once
#include <functional>
#include "tcp_socket.hpp"

typedef std::function<void (const std::string& req, std::string* resp)> Handler;

class TcpServer 
{
 public:
     TcpServer(const std::string& ip, uint16_t port) : ip_(ip), port_(port) {
 }

bool Start(Handler handler) 
{
     // 1. 创建 socket;
     CHECK_RET(listen_sock_.Socket());
     // 2. 绑定端口号
     CHECK_RET(listen_sock_.Bind(ip_, port_));
     // 3. 进行监听
     CHECK_RET(listen_sock_.Listen(5));
     // 4. 进入事件循环
     for (;;) 
    {
         // 5. 进行 accept
         TcpSocket new_sock;
         std::string ip;
         uint16_t port = 0;
         if (!listen_sock_.Accept(&new_sock, &ip, &port)) 
        {
             continue;
         }
         printf("[client %s:%d] connect!\n", ip.c_str(), port);
         // 6. 进行循环读写
         for (;;) 
        {
             std::string req;
             // 7. 读取请求. 读取失败则结束循环
             bool ret = new_sock.Recv(&req);
             if (!ret) 
            {
                 printf("[client %s:%d] disconnect!\n", ip.c_str(), port);
                 // [注意!] 将此处的关闭 socket 去掉
                 // new_sock.Close();
                 break;
            }
             // 8. 计算响应
             std::string resp;
             handler(req, &resp);
             // 9. 写回响应
             new_sock.Send(resp);
             printf("[%s:%d] req: %s, resp: %s\n", ip.c_str(), port,
             req.c_str(), resp.c_str());
         }
     }
 return true;
}
private:
     TcpSocket listen_sock_;
     std::string ip_;
     uint64_t port_;
};

• 窗口大小指的是无需等待确认应答而可以继续发送数据的最大值. 上图的窗口大小就是4000个字节(四个段)；
• 发送前四个段的时候, 不需要等待任何ACK, 直接发送；

• 收到第一个ACK后, 滑动窗口向后移动, 继续发送第五个段的数据; 依次类推；
• 操作系统内核为了维护这个滑动窗口, 需要开辟 发送缓冲区 来记录当前还有哪些数据没有应答; 只有确认应答过的数据, 才能从缓冲区删掉；
• 窗口越大, 则网络的吞吐率就越高；

这种情况下, 部分ACK丢了并不要紧, 因为可以通过后续的ACK进行确认;

• 接收端将自己可以接收的缓冲区大小放入 TCP 首部中的 "窗口大小" 字段, 通过ACK端通知发送端；
• 窗口大小字段越大, 说明网络的吞吐量越高；
• 接收端一旦发现自己的缓冲区快满了, 就会将窗口大小设置成一个更小的值通知给发送端；
• 发送端接受到这个窗口之后, 就会减慢自己的发送速度；
• 如果接收端缓冲区满了, 就会将窗口置为0; 这时发送方不再发送数据, 但是需要定期发送一个窗口探测数据段, 使接收端把窗口大小告诉发送端；

接收端如何把窗口大小告诉发送端呢? 回忆我们的TCP首部中, 有一个16 位窗口字段 , 就是存放了窗口大小信息 ;

• 此处引入一个概念程为拥塞窗口；
• 发送开始的时候, 定义拥塞窗口大小为1；
• 每次收到一个ACK应答, 拥塞窗口加1；
• 每次发送数据包的时候, 将拥塞窗口和接收端主机反馈的窗口大小做比较, 取较小的值作为实际发送的窗口；

• 为了不增长的那么快, 因此不能使拥塞窗口单纯的加倍；
• 此处引入一个叫做慢启动的阈值；
• 当拥塞窗口超过这个阈值的时候, 不再按照指数方式增长, 而是按照线性方式增长；

• 当TCP开始启动的时候, 慢启动阈值等于窗口最大值;
• 在每次超时重发的时候, 慢启动阈值会变成原来的一半, 同时拥塞窗口置回1;

延迟应答

• 假设接收端缓冲区为1M. 一次收到了500K的数据; 如果立刻应答, 返回的窗口就是500K；
• 但实际上可能处理端处理的速度很快, 10ms之内就把500K数据从缓冲区消费掉了；
• 在这种情况下, 接收端处理还远没有达到自己的极限, 即使窗口再放大一些, 也能处理过来；
• 如果接收端稍微等一会再应答, 比如等待200ms再应答, 那么这个时候返回的窗口大小就是1M；

一定要记得, 窗口越大, 网络吞吐量就越大, 传输效率就越高. 我们的目标是在保证网络不拥塞的情况下尽量提高传输效率；

• 数量限制: 每隔N个包就应答一次；
• 时间限制: 超过最大延迟时间就应答一次；

捎带应答

面向字节流

粘包问题

• 首先要明确, 粘包问题中的 "包" , 是指的应用层的数据包；
• 在TCP的协议头中, 没有如同UDP一样的 "报文长度" 这样的字段, 但是有一个序号这样的字段;
• 站在传输层的角度, TCP是一个一个报文过来的. 按照序号排好序放在缓冲区中；
• 站在应用层的角度, 看到的只是一串连续的字节数据；
• 那么应用程序看到了这么一连串的字节数据, 就不知道从哪个部分开始到哪个部分, 是一个完整的应用层数据包；

• 对于定长的包, 保证每次都按固定大小读取即可; 例如上面的Request结构, 是固定大小的, 那么就从缓冲区从头开始按sizeof(Request)依次读取即可；
• 对于变长的包, 可以在包头的位置, 约定一个包总长度的字段, 从而就知道了包的结束位置；
• 对于变长的包, 还可以在包和包之间使用明确的分隔符(应用层协议, 是程序猿自己来定的, 只要保证分隔符不和正文冲突即可)；

• 对于UDP, 如果还没有上层交付数据, UDP的报文长度仍然在. 同时, UDP是一个一个把数据交付给应用层. 就有很明确的数据边界；
• 站在应用层的站在应用层的角度, 使用UDP的时候, 要么收到完整的UDP报文, 要么不收. 不会出现"半个"的情况；

TCP异常情况

TCP小结

• 引入确认应答, 确保对端收到了数据;
• 引入超时重传, 如果隔一段时间没有应答, 就重发数据;
• ......

TCP 相关实验

理解 listen 的第二个参数

• test_server.cc

#include "tcp_socket.hpp"
int main(int argc, char* argv[]) {
 if (argc != 3) {
 printf("Usage ./test_server [ip] [port]\n");
 return 1;
 }
 TcpSocket sock;
 bool ret = sock.Bind(argv[1], atoi(argv[2]));
 if (!ret) {
 return 1;
 }
 ret = sock.Listen(2);
 if (!ret) {
 return 1;
 }
 // 客户端不进行 accept
 while (1) {
 sleep(1);
 }
 return 0;
}

• test_client.cc

#include "tcp_socket.hpp"
int main(int argc, char* argv[]) {
 if (argc != 3) {
 printf("Usage ./test_client [ip] [port]\n");
 return 1;
 }
 TcpSocket sock;
 bool ret = sock.Connect(argv[1], atoi(argv[2]));
 if (ret) {
 printf("connect ok\n");
 } else {
 printf("connect failed\n");
 }
 while (1) {
 sleep(1);
 }
 return 0;
}

ip.addr == [服务器 ip]

则只抓取指定 ip 的数据包 .

tcp.port == 9090

观察三次握手过程

启动好服务器 .

使用 telnet 作为客户端连接上服务器

telnet [ip] [port]

抓包结果如下 :

观察三个报文各自的序列号和确认序号的规律 .

在中间部分可以看到 TCP 报文详细信息

观察确认应答

在 telnet 中输入一个字符

可以看到客户端发送一个长度为 1 字节的数据 , 此时服务器返回了一个 ACK 以及一个 9 个字节的响应 ( 捎带应答 ), 然后客户端再反馈一个 ACK( 注意观察 序列号和确认序号 )；

观察四次挥手

在 telnet 中输入 ctrl + ], 回到 telnet 控制界面 , 输入 quit 退出；

实际上是 " 三次挥手 ", 由于捎带应答 , 导致其中的两次重合在了一起；

注意事项

如果使用虚拟机部署服务器 , 建议使用 " 桥接网卡 " 的方式连接网络 . NAT 方式下由于进行了 ip 和 port 的替换 .

使用云服务器测试 , 更加直观方便 .