C# 使用Pcap.Net分割Ipv6数据包

因此，我为IpV4找到了这个解决方案：

private IEnumerable<Packet> SplitPacket(Packet packet, int numberOfFragments)
{
    IpV4Datagram ipV4Datagram = packet.Ethernet.IpV4;

    if (ipV4Datagram.Protocol == IpV4Protocol.Tcp || ipV4Datagram.Protocol == IpV4Protocol.Udp)
    {
        EthernetLayer ethernet = (EthernetLayer)packet.Ethernet.ExtractLayer();
        ILayer layer = packet.Ethernet.IpV4.ExtractLayer();
        IpV4Layer ipV4Layer = (IpV4Layer)packet.Ethernet.IpV4.ExtractLayer();
        ipV4Layer.HeaderChecksum = null;
        DateTime packetTimestamp = packet.Timestamp;
        PayloadLayer payload = (PayloadLayer)packet.Ethernet.IpV4.Payload.ExtractLayer(); //extract the data
        int totalLength = payload.Length;
        int partialLength = totalLength / numberOfFragments; //split data into smaller segments
        partialLength = (partialLength / 8) * 8; //make sure it's divisible with 8
        if (partialLength == 0)
            partialLength = 8;
        //(http://en.wikipedia.org/wiki/IPv4#Fragmentation_and_reassembly)
        ushort offset = 0; //send one by one

        while (offset < totalLength)
        {
            int fragmentLength = partialLength; //get length for this fragment
            IpV4FragmentationOptions options = IpV4FragmentationOptions.MoreFragments;

            if (offset + fragmentLength >= totalLength) //is this the last fragment ? trim length if needed
            {
                options = IpV4FragmentationOptions.None;
                fragmentLength = totalLength - offset;
            }

            byte[] newBuffer = ipV4Datagram.Payload.ToArray(); //copy the actual data into a new buffer
            PayloadLayer newPayload = new PayloadLayer { Data = new Datagram(newBuffer, offset, fragmentLength) };
            ipV4Layer.Fragmentation = new IpV4Fragmentation(options, offset); //change IP layer fragmentation options
            Packet newPacket = null;

            if (packet.Ethernet.IpV4.Protocol == IpV4Protocol.Tcp)
            {
                TcpLayer tcpLayer = (TcpLayer)packet.Ethernet.IpV4.Tcp.ExtractLayer();
                tcpLayer.Checksum = null;
                newPacket = PacketBuilder.Build(packetTimestamp, ethernet, ipV4Layer, tcpLayer, newPayload);
            }
            else if (packet.Ethernet.IpV4.Protocol == IpV4Protocol.Udp)
            {
                UdpLayer udpLayer = (UdpLayer)packet.Ethernet.IpV4.Udp.ExtractLayer();
                udpLayer.Checksum = null;
                newPacket = PacketBuilder.Build(packetTimestamp, ethernet, ipV4Layer, udpLayer, newPayload);
            }

            yield return newPacket;
            //yield return PacketBuilder.Build(packetTimestamp, ethernet, ipV4Layer, tcpLayer, newPayload); //return
            offset += (ushort)fragmentLength; //next offset
        }
    }
}

private IEnumerable SplitPacket（数据包包，int numberOfFragments）
{
IpV4数据报IpV4数据报=packet.Ethernet.IpV4；
if（ipV4Datagram.Protocol==IpV4Protocol.Tcp | | ipV4Datagram.Protocol==IpV4Protocol.Udp）
{
EthernetLayer ethernet=（EthernetLayer）packet.ethernet.ExtractLayer（）；
ILayer layer=packet.Ethernet.IpV4.ExtractLayer（）；
IpV4Layer IpV4Layer=（IpV4Layer）packet.Ethernet.IpV4.ExtractLayer（）；
ipV4Layer.HeaderChecksum=null；
DateTime packetTimestamp=packet.Timestamp；
PayloadLayer有效负载=（PayloadLayer）packet.Ethernet.IpV4.payload.ExtractLayer（）；//提取数据
int totalLength=有效载荷长度；
int partialLength=totalLength/numberOfFragments；//将数据分割成更小的段
partialLength=（partialLength/8）*8；//确保它可以被8整除
if（partialLength==0）
部分长度=8；
//(http://en.wikipedia.org/wiki/IPv4#Fragmentation_and_reassembly)
ushort offset=0；//逐个发送
而（偏移量<总长度）
{
int fragmentLength=partialLength；//获取此片段的长度
IpV4FragmentationOptions=IpV4FragmentationOptions.MoreFragments；
if（offset+fragmentLength>=totalLength）//这是最后一个片段吗？如果需要，修剪长度
{
选项=IPV4碎片选项。无；
碎片长度=总长度-偏移量；
}
byte[]newBuffer=ipV4Datagram.Payload.ToArray（）；//将实际数据复制到新的缓冲区中
PayloadLayer newPayload=new PayloadLayer{Data=new Datagram（newBuffer，offset，fragmentLength）}；
ipV4Layer.Fragmentation=新IpV4Fragmentation（选项，偏移量）；//更改IP层碎片选项
数据包newPacket=null；
if（packet.Ethernet.IpV4.Protocol==IpV4Protocol.Tcp）
{
TcpLayer TcpLayer=（TcpLayer）packet.Ethernet.IpV4.Tcp.ExtractLayer（）；
tcpLayer.Checksum=null；
newPacket=PacketBuilder.Build（packetTimestamp、以太网、ipV4Layer、tcpLayer、newPayload）；
}
else if（packet.Ethernet.IpV4.Protocol==IpV4Protocol.Udp）
{
UdpLayer UdpLayer=（UdpLayer）packet.Ethernet.IpV4.Udp.ExtractLayer（）；
udpLayer.Checksum=null；
newPacket=PacketBuilder.Build（packetTimestamp、以太网、ipV4Layer、udpLayer、newPayload）；
}
产生返回新包；
//yield return PacketBuilder.Build（packetTimestamp，ethernet，ipV4Layer，tcpLayer，newPayload）；//return
偏移量+=（ushort）碎片长度；//下一个偏移量
}
}
}

由于

Ipv6Layer

不包含像

IpV4layer

中的几个字段，例如

IpV4FragmentationOptions

我想知道

Fragmentation

是如何通过

IpV6

实现的：

碎片化

与IPv4不同，IPv6路由器从不分割IPv6数据包。小包 超过目标的最大传输单元的大小 链路被丢弃，这种情况是由太大的数据包发出的信号 发送到发起节点的ICMPv6类型2消息，类似于IPv4 方法，当设置了“不分段”位时

IPv6中的终端节点应执行到的路径MTU发现 确定要发送的数据包的最大大小以及上层 协议将限制有效负载的大小。然而，如果 上层协议无法执行此操作，发送主机可能会使用 用于执行端到端分段的片段扩展标头 IPv6数据包的数量。任何传输IPv6数据的数据链路层都必须 能够传送包含1280字节的IP数据包，而无需 需要在IP层调用端到端碎片

碎片化

包含原始（较大）数据包片段的数据包由 由两部分组成：原始数据包的不可分割部分（即 所有碎片都是一样的），以及 原始数据包，由片段偏移量标识。碎片 第一个（“最左边”）片段的偏移量为0

数据包的不可分割部分由固定的报头和 原始数据包的一些扩展头（如果存在）：全部 路由扩展标头之前（包括路由扩展标头）的扩展标头，或 否则将显示逐跳扩展标头。如果两个扩展标头都不存在 目前，不可分割的部分只是固定的标题

文件的最后一个（扩展）标题的下一个标题值 “不可分割部分”设置为44以指示片段扩展 标题如下。在片段扩展头之后是 原始数据包的其余部分如下

第一个片段包含其余的扩展头（如果 现在）。之后，剩余的有效载荷将跟随。每个片段都是 长度为8个八位字节的倍数，最后一个片段除外

每个片段扩展头都将其M标志设置为1（表示 接下来是更多的片段），但最后一个片段除外，它的标志设置为0

重新组装

原始数据包由接收节点通过收集重新组装 所有碎片，并将每个碎片放置在正确的偏移位置，然后 丢弃携带的数据包的片段扩展头 他们。包含片段的数据包不需要按顺序到达；他们 将由接收节点重新排列

如果在接收后60秒内未接收到所有碎片 第一个带有片段的数据包，是原始数据包的重新组装 丢弃所有碎片