手写TCP/IP——第8节TCP协议的实现4——基本TCP输入处理(TCP包头定义+复位包处理)

Ethan Yankang

已于 2024-10-08 20:21:28 修改

阅读量331

点赞数 2

文章标签： tcp/ip 网络协议网络

于 2024-10-08 20:17:07 首次发布

本文链接：https://blog.csdn.net/m0_68657832/article/details/142767590

版权

🌈hello，你好鸭，我是Ethan，西安电子科技大学大三在读，很高兴你能来阅读。

✔️目前博客主要更新Java系列、项目案例、计算机必学四件套等。
🏃人生之义，在于追求，不在成败，勤通大道。加油呀！

🔥个人主页：Ethan Yankang
🔥推荐：史上最强八股文||一分钟看完我的几百篇博客

🔥温馨提示：划到文末发现专栏彩蛋点击这里直接传送

🔥本篇概览：详细讲解了手写TCP/IP——第8节TCP协议的实现4——基本TCP输入处理(TCP包头定义+复位包处理)。🌈⭕🔥

【计算机领域一切迷惑的源头都是基本概念的模糊，算法除外】

🔥 手写底层系列

🔥 手写TCP/IP系列

【OSI与课程讲解】

🌈章节引出：

前一篇章：

🌈章节速览：

1.TCP包头结构

2.实际抓包过程

3.TCP包头结构

typedef struct _xtcp_hdr_t {
    uint16_t src_port, dest_port;	 // 源端口 + 目标端口
    uint32_t seq;		            // 自己发送的数据的起始序号
    uint32_t ack;		            // 通知对方期望接收的下一字节的序号
    union {
        struct {

#define XTCP_FLAG_FIN           (1 << 0)
#define XTCP_FLAG_SYN           (1 << 1)
#define XTCP_FLAG_RST           (1 << 2)
#define XTCP_FLAG_ACK           (1 << 4)

            uint16_t flags : 6;         // 标志位
            uint16_t reserved : 6;      // 保留位
            uint16_t hdr_len: 4;        // 首部长度，以4字节位为单位
        };
        uint16_t all;
    }hdr_flags;
    uint16_t window;	            // 窗口大小，告诉对方自己能接收多少数据
    uint16_t checksum;	            // 校验和
    uint16_t urgent_ptr;	        // 紧急指针
}xtcp_hdr_t;

4.TCP输入函数

/**
 * TCP包的输入处理
 */
void xtcp_in(xipaddr_t *remote_ip, xnet_packet_t * packet) {
    xtcp_hdr_t * tcp_hdr = (xtcp_hdr_t *)packet->data;
    xtcp_t* tcp;
    uint16_t pre_checksum;

    // 大小检查，至少要有负载数据
    if (packet->size < sizeof(xtcp_hdr_t)) {
        return;
    }

//校验和的检查
    pre_checksum = tcp_hdr->checksum;
    tcp_hdr->checksum = 0;
    if (pre_checksum != 0) {
        uint16_t checksum = checksum_peso(remote_ip, &netif_ipaddr, XNET_PROTOCOL_TCP, (uint16_t*)tcp_hdr, packet->size);
        checksum = (checksum == 0) ? 0xFFFF : checksum;
        if (checksum != pre_checksum) {
            return;
        }
    }
    // 从包头中解析相关参数，并进行大小端的转换
    tcp_hdr->src_port = swap_order16(tcp_hdr->src_port);
    tcp_hdr->dest_port = swap_order16(tcp_hdr->dest_port);
    tcp_hdr->hdr_flags.all = swap_order16(tcp_hdr->hdr_flags.all);
    tcp_hdr->seq = swap_order32(tcp_hdr->seq);
    tcp_hdr->ack = swap_order32(tcp_hdr->ack);
    tcp_hdr->window = swap_order16(tcp_hdr->window);

    // 找到对应处理的tcb，可能是监听tcb，也可能是已经连接的tcb，没有处理项，则复位通知
    tcp = tcp_find(remote_ip, tcp_hdr->src_port, tcp_hdr->dest_port);
    if (tcp == (xtcp_t *)0) {
        // 暂时先写成seq + 1，后面再改
        tcp_send_reset(tcp_hdr->seq + 1, tcp_hdr->dest_port, remote_ip, tcp_hdr->src_port);
        return;
    }
}

核心注意这里的代码：

// 暂时先写成seq + 1，后面再改
tcp_send_reset(tcp_hdr->seq + 1, tcp_hdr->dest_port, remote_ip, tcp_hdr->src_port);

tcp_hdr->seq + 1

是为了通知你我接受到你上一次发给我的包了。

这就是二次握手的回送的ACK包。

5.在IP协议中添加对TCP协议的上层实现

/**
 * IP层的输入处理
 * @param packet 输入的IP数据包
 */
void xip_in(xnet_packet_t * packet) {
    xip_hdr_t* iphdr = (xip_hdr_t*)packet->data;
    uint32_t total_size, header_size;
    uint16_t pre_checksum;
    xipaddr_t src_ip;

    // 进行一些必要性的检查：版本号要求
    if (iphdr->version != XNET_VERSION_IPV4) {
        return;
    }

    // 长度要求检查
    header_size = iphdr->hdr_len * 4;
    total_size = swap_order16(iphdr->total_len);
    if ((header_size < sizeof(xip_hdr_t)) || ((total_size < header_size) || (packet->size < total_size))) {
        return;
    }

    // 校验和要求检查
    pre_checksum = iphdr->hdr_checksum;
    iphdr->hdr_checksum = 0;
    if (pre_checksum != checksum16((uint16_t*)iphdr, header_size, 0, 1)) {
        return;
    }
    iphdr->hdr_checksum = pre_checksum;

    // 只处理目标IP为自己的数据包，其它广播之类的IP全部丢掉
    if (!xipaddr_is_equal_buf(&netif_ipaddr, iphdr->dest_ip)) {
        return;
    }

    xipaddr_from_buf(&src_ip, iphdr->src_ip);
    switch(iphdr->protocol) {
        case XNET_PROTOCOL_UDP:
            if (packet->size >= sizeof(xudp_hdr_t)) {
                xudp_hdr_t *udp_hdr = (xudp_hdr_t *) (packet->data + header_size);
                xudp_t *udp = xudp_find(swap_order16(udp_hdr->dest_port));
                if (udp) {
                    truncate_packet(packet, total_size);
                    remove_header(packet, header_size);
                    xudp_in(udp, &src_ip, packet);
                } else {
                    xicmp_dest_unreach(XICMP_CODE_PORT_UNREACH, iphdr);
                }
            }
            break;
        case XNET_PROTOCOL_TCP:
            truncate_packet(packet, total_size);
            remove_header(packet, header_size);
            xtcp_in(&src_ip, packet);
            break;
        case XNET_PROTOCOL_ICMP:
            remove_header(packet, header_size);
            xicmp_in(&src_ip, packet);
            break;
        default:
            // 这里应当写成协议不可达，因为没有任何协议能处理输入数据包
            xicmp_dest_unreach(XICMP_CODE_PRO_UNREACH, iphdr);
            break;
    }
}

核心添加了：

  case XNET_PROTOCOL_TCP:
            truncate_packet(packet, total_size);
            remove_header(packet, header_size);
            xtcp_in(&src_ip, packet);
            break;

6.发送TCP复位包

复位包作用：

发送 TCP 复位包是指在 TCP 连接中，发送一个带有特定标志位（复位标志 “RST”）的 TCP 数据包，以立即终止该 TCP 连接。

触发场景：

当接收方收到的 TCP 数据包对于当前连接而言是不正确的、不期望的或无法处理的，例如数据包的序列号不连续、端口号不匹配等，接收方会发送 TCP 复位包。比如，服务器上的某个应用程序已经关闭了监听的端口，但客户端仍然向该端口发送数据，服务器就会发送复位包来终止这个无效的连接。

/**
 * 发送TCP复位包
 */
static xnet_err_t tcp_send_reset (uint32_t remote_ack, uint16_t local_port, xipaddr_t * remote_ip, uint16_t remote_port) {
    xnet_packet_t * packet = xnet_alloc_for_send(sizeof(xtcp_hdr_t));
    xtcp_hdr_t * tcp_hdr = (xtcp_hdr_t *)packet->data;

    tcp_hdr->src_port = swap_order16(local_port);
    tcp_hdr->dest_port = swap_order16(remote_port);
    tcp_hdr->seq = 0;                                   // 固定为0即可
    tcp_hdr->ack = swap_order32(remote_ack);            // 响应指定的发送ack，即对上次发送的包的回应
    tcp_hdr->hdr_flags.all = 0;
    tcp_hdr->hdr_flags.hdr_len = sizeof(xtcp_hdr_t) / 4;
    tcp_hdr->hdr_flags.flags = XTCP_FLAG_RST | XTCP_FLAG_ACK;
    tcp_hdr->hdr_flags.all = swap_order16(tcp_hdr->hdr_flags.all);
    tcp_hdr->window = 0;
    tcp_hdr->urgent_ptr = 0;
    tcp_hdr->checksum = 0;
    tcp_hdr->checksum = checksum_peso(&netif_ipaddr, remote_ip, XNET_PROTOCOL_TCP, (uint16_t *) packet->data, packet->size);
    tcp_hdr->checksum = tcp_hdr->checksum ? tcp_hdr->checksum : 0xFFFF;
    return xip_out(XNET_PROTOCOL_TCP, remote_ip, packet);
}

32位大小端转化：

#define swap_order32(v)   ((((v >> 0) & 0xFF) << 24) | (((v >> 8) & 0xFF) << 16) | (((v >> 16) & 0xFF) << 8) | ((v >> 24) & 0xFF))

或者下面的代码

uint32_t swap_order32(uint32_t v) {
    uint32_t r_v;
    uint8_t* src = (uint8_t*)&v;
    uint8_t* dest = (uint8_t*)&r_v;

    dest[0] = src[3];
    dest[1] = src[2];
    dest[2] = src[1];
    dest[3] = src[0];
    return r_v;
}

💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖

热门专栏推荐

🌈🌈计算机科学入门系列 关注走一波💕💕