IP分片：发生在网络层，由IP协议处理，由于网络链路层的MTU（最大传输单元）限制，当IP数据报大小超过MTU时，需要进行分片。
TCP分片：发生在传输层，由TCP协议处理，为了适应MSS（最大分段大小），避免IP层分片，TCP会根据MSS对数据进行分段。

// defrag.h - 分片重组的主要数据结构
typedef struct DefragTracker_ {
    SCMutex lock;        // 互斥锁保护
    uint32_t id;         // IP 包 ID
    uint8_t proto;       // IP 协议
    uint8_t policy;      // 重组策略
    uint8_t af;          // 地址族(IPv4/IPv6)
    uint8_t seen_last;   // 是否看到最后一个分片
    Address src_addr;    // 源地址
    Address dst_addr;    // 目的地址
    struct IP_FRAGMENTS fragment_tree; // 分片树
} DefragTracker;

// 单个分片的结构
typedef struct Frag_ {
    uint16_t offset;     // 分片偏移 
    uint32_t len;        // 分片长度
    uint8_t more_frags;  // 是否还有更多分片
    uint8_t *pkt;        // 实际分片数据
    RB_ENTRY(Frag_) rb;  // 红黑树节点
} Frag;

// decode-ipv4.c 中的处理流程
int DecodeIPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint16_t len)
{
    // 1. 检测到分片标记
    if (IPV4_GET_RAW_FRAGOFFSET(ip4h) > 0 || IPV4_GET_RAW_FLAG_MF(ip4h)) {
        // 2. 调用 Defrag 进行重组
        Packet *rp = Defrag(tv, dtv, p);
        if (rp != NULL) {
            // 3. 重组成功,将重组后的包加入队列
            PacketEnqueueNoLock(&tv->decode_pq, rp);
        }
        p->flags |= PKT_IS_FRAGMENT;
        return TM_ECODE_OK;
    }
}

// 分片重组的主函数
Packet *Defrag(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p) 
{
    // 1. 创建/查找分片追踪器
    // 2. 将分片加入分片树
    // 3. 检查是否可以重组
    // 4. 重组分片生成新包
    // 5. 返回重组后的包
}

// 处理 IPv6 分片头
void DecodeIPV6FragHeader(Packet *p, const uint8_t *pkt, uint16_t hdrextlen, 
                         uint16_t plen, uint16_t prev_hdrextlen)
{
    // 解析分片头
    // 设置分片标记
    // 进行合法性检查
}

使用分片跟踪器(DefragTracker)和分片树管理分片
支持 IPv4 和 IPv6 协议
有完善的错误检测机制
通过队列管理重组后的包
采用互斥锁保证线程安全
这个实现比较完整地覆盖了 IP 分片重组的各个方面,包括分片识别、存储、重组、验证等环节。

// src/analyzer/protocol/tcp/TCP_Reassembler.h
// TCP_Reassembler 类
class TCP_Reassembler final : public Reassembler {
    enum Type {
        Direct,  // 直接传递到目标分析器 
        Forward  // 转发到目标分析器的子节点
    }; 

    TCP_Endpoint* endp;        // TCP 端点
    bool had_gap;             // 是否有数据空洞
    bool deliver_tcp_contents; // 是否传递TCP内容
    uint64_t seq_to_skip;     // 要跳过的序列号
    FilePtr record_contents_file; // 记录内容的文件
};

// src/packet_analysis/protocol/tcp/TCPSessionAdapter.h
// TCPSessionAdapter 类
class TCPSessionAdapter {
    TCP_Endpoint* orig;         // 发起方端点
    TCP_Endpoint* resp;         // 响应方端点
    bool reassembling;          // 是否正在重组
    bool is_partial;            // 是否部分连接
    uint64_t rel_data_seq;      // 相对数据序列号
};

// 启用重组:
void TCPSessionAdapter::EnableReassembly() {
    SetReassembler(
        new TCP_Reassembler(this, TCP_Reassembler::Forward, orig),
        new TCP_Reassembler(this, TCP_Reassembler::Forward, resp)
    );
}

// 数据到达处理:
// src/analyzer/protocol/tcp/TCP_Reassembler.cc - TCP 重组器实现

void TCP_Reassembler::DataSent(double t, uint64_t seq, int len, 
                              const u_char* data) {

    // 检查是否需要跳过
    if (IsSkippedContents(seq, len)) 
        return;

    // 处理数据空洞
    if (seq > last_reassem_seq) {
        Gap(last_reassem_seq, seq - last_reassem_seq);
        had_gap = true;
    }

    // 交付数据
    DeliverBlock(seq, len, data);
}

// src/packet_analysis/protocol/tcp/TCPSessionAdapter.cc
void TCPSessionAdapter::Process(bool is_orig, const struct tcphdr* tp,
                              int len, const IP_Hdr* ip) {
    // 获取序列号    
    uint32_t base_seq = ntohl(tp->th_seq);

    // 处理标志位
    TCP_Flags flags(tp);

    // 分析状态
    UpdateStateMachine(t, endpoint, peer, base_seq, flags); 

    // 数据重组
    if (len > 0 && !flags.RST())
        endpoint->DataSent(t, base_seq, len, data);
}



//  空洞处理:
void TCP_Reassembler::Gap(uint64_t seq, uint64_t len) {
    // 报告空洞
    if (report_gap(endp, endp->peer))
        dst_analyzer->EnqueueConnEvent(content_gap, ...);

    // 更新状态
    had_gap = true;
}


// 跟踪 TCP 状态:
void TCPSessionAdapter::UpdateStateMachine(TCP_Endpoint* endpoint,
    TCP_Endpoint* peer, uint32_t seq, TCP_Flags flags)
{
    // SYN 处理
    if (flags.SYN()) {
        if (is_orig) {
            endpoint->SetState(TCP_ENDPOINT_SYN_SENT);
        } else {
            endpoint->SetState(TCP_ENDPOINT_ESTABLISHED); 
        }
    }

    // FIN 处理  
    if (flags.FIN()) {
        endpoint->SetState(TCP_ENDPOINT_CLOSED);
    }

    // RST 处理
    if (flags.RST()) {
        endpoint->SetState(TCP_ENDPOINT_RESET);
    }
}

    TCP_Reassembler: 专门负责重组的核心组件
    TCPSessionAdapter: 管理整个 TCP 会话的组件

数据排序
检查序列号是否连续
如果是期望的下一个序列号,直接处理
如果不是,放入缓存等待处理
空洞处理
当发现序列号不连续时,记录为"空洞"
继续接收后续数据,等待空洞被填补

序列号跟踪
记录已处理的最后序列号
检查新数据的序列号是否符合预期
缓存管理
对乱序到达的数据进行缓存
定期清理过期的缓存数据
状态跟踪
跟踪连接状态(SYN, FIN, RST等)
根据状态决定如何处理数据

每张明信片都有序号(序列号)
你需要按顺序排列它们才能看到完整图片
有时候明信片到达的顺序是乱的(乱序数据)
有时候有明信片丢失了(数据空洞)
你需要等待缺失的明信片(填补空洞)
最后将所有明信片按顺序排好(重组完成)

// TCP 流结构
typedef struct {
    uint32_t src_ip;
    uint32_t dst_ip;
    uint16_t src_port;
    uint16_t dst_port;
    uint32_t next_seq;    // 关键字段：下一个期望的序列号
    uint32_t init_seq;    // 初始序列号
    time_t last_seen;
    unsigned char *stream;  // 存储重组数据的缓冲区
    int stream_size;       // 当前已重组的数据大小
    flow_state state;
    char src_ip_str[INET_ADDRSTRLEN];
    char dst_ip_str[INET_ADDRSTRLEN];
} tcp_flow_t;

// 全局变量
tcp_flow_t flows[MAX_FLOWS];
int flow_count = 0;

void handle_tcp_packet(const struct ip *ip_header, const struct tcphdr *tcp_header,
                       const unsigned char *payload, int payload_len) {
    tcp_flow_t *flow = find_or_create_flow(ip_header, tcp_header);
    if (!flow) return;

    if (tcp_header->th_flags & TH_SYN) {
        if (flow->state == FLOW_NEW) {
            flow->state = FLOW_ESTABLISHED;
            flow->next_seq = ntohl(tcp_header->th_seq) + 1;  // SYN包，序列号+1
            print_flow_info(flow, "SYN");
        }
    }
    else if (tcp_header->th_flags & TH_FIN || tcp_header->th_flags & TH_RST) {
        flow->state = FLOW_CLOSED;
        print_flow_info(flow, tcp_header->th_flags & TH_FIN ? "FIN" : "RST");
        process_stream_data(flow);
    }
    else if (payload_len > 0) {
        uint32_t seq = ntohl(tcp_header->th_seq);
        if (seq == flow->next_seq) {  // 关键重组逻辑：检查序列号是否符合预期
            // 确保不会超出缓冲区
            int copy_len = payload_len;
            if (flow->stream_size + copy_len > MAX_STREAM_SIZE) {
                copy_len = MAX_STREAM_SIZE - flow->stream_size;
            }

            if (copy_len > 0) {
                // 按序复制数据到重组缓冲区
                memcpy(flow->stream + flow->stream_size, payload, copy_len);
                flow->stream_size += copy_len;
                flow->next_seq = seq + copy_len;  // 更新下一个期望的序列号
                flow->state = FLOW_DATA;
                print_flow_info(flow, "DATA");
            }
        }
    }
}