假如你想自定义一个网络协议

标签：自定义示例网络协议 packet 假如 new byte data public

一、引言

在当今数字化时代，网络通信无处不在。虽然现有的 TCP/IP 协议簇已广泛应用且极为成熟，但在某些特定场景下，如工业控制网络、科研专用网络、对安全性和性能有特殊要求的军事通信等领域，自定义网络协议具有独特优势。它能够根据具体需求精细优化网络性能、强化安全保障、适配特殊的硬件环境，为解决复杂的网络问题提供定制化方案。接下来将深入探讨如何从数据链路层开始，一步步构建自定义的类似 TCP 的网络协议。

二、数据链路层自定义

帧格式设计
- 帧起始与结束标志：借鉴以太网的做法，选取特定的字节序列作为帧起始标志（如 0x7E）和帧结束标志（如 0x7E），以便接收端能准确识别一帧的边界。但需注意，若数据中出现与标志相同的序列，要采用转义机制，如插入额外字节（0x7D）进行标识，接收端再做相应还原。
- 地址字段：包含源数据链路层地址和目的数据链路层地址，可根据实际网络规模和设备布局设计地址长度。若网络为小型局域网，如工厂车间内的设备组网，4 字节或 6 字节地址即可满足，且可自行分配唯一标识符给各节点。
- 控制字段：用于承载如流量控制、差错控制相关的子字段。例如，设置 1 位的流量控制位，当接收端缓存快满时，向发送端发送置位该位的帧，通知发送端暂停发送；设置 2 位的差错控制子字段，00 表示无差错，01 表示奇偶校验错，10 表示 CRC 校验错等，便于发送端快速了解接收情况并采取措施。
- 数据字段：承载上层（网络层）传递下来的数据，其长度依据网络带宽、传输延迟等因素综合确定。若网络带宽较低，为减少传输延迟，适当缩短数据字段长度，优先保证关键控制信息的传输。
- 校验字段：采用 CRC（循环冗余校验）算法生成校验码，填充在此字段。发送端依据帧内数据计算 CRC 码并放入校验字段，接收端以相同算法验算，若结果不一致则判定帧出错，要求发送端重发。
介质访问控制（MAC）
- 若网络为共享介质环境，类似传统以太网，可采用 CSMA/CD（带冲突检测的载波侦听多路访问）机制。节点在发送数据前，先侦听介质状态，若忙则等待；发送过程中持续检测是否冲突，一旦检测到冲突，立即停止发送并随机退避一段时间后再尝试。
- 对于无线自组网等场景，可采用 CSMA/CA（带冲突避免的载波侦听多路访问）机制。由于无线信号传播特性，难以实时检测冲突，所以节点发送前先发送一小段请求发送（RTS）信号，接收端回复允许发送（CTS）信号后，发送端才正式发送数据，以此降低冲突概率。
- 在对实时性要求极高的工业控制网络中，若节点有明确优先级，可引入令牌传递机制。网络中有一个特殊的令牌在节点间按优先级顺序循环传递，只有持有令牌的节点才能发送数据，确保高优先级节点数据及时传输，满足实时控制需求。

三、网络层自定义

分组格式设计
- 版本与首部长度：设定版本号，用于区分协议不同版本，方便后续升级兼容。首部长度字段明确表示分组首部所占字节数，以字节为单位，便于接收端准确解析后续字段。
- 服务类型：根据网络应用需求划分服务类型，如设置低延迟服务类型，针对实时语音、视频传输；高吞吐量服务类型，面向大数据批量传输应用。通过不同的服务类型标记，网络设备可针对性地提供路由、转发策略。
- 总长度：指明包括首部和数据部分在内的分组总字节长度，确保接收端完整接收。当分组跨不同网络传输，网络设备依据此长度进行分片、重组操作。
- 标识符、标志与片偏移：用于分组分片场景。标识符唯一标识一个分组，标志位中的 MF（More Fragment）位指示是否还有后续分片，DF（Don't Fragment）位规定能否分片，片偏移指明该片在原始分组中的相对位置，保证接收端正确重组分片。
- 生存时间（TTL）：初始设定一定值，如 32 或 64，分组每经过一跳路由转发，TTL 减 1，当 TTL 为 0 时，丢弃该分组，防止因路由环路导致分组在网络中无限循环。
- 协议：标识上层协议类型，如对应传输层的自定义 TCP 协议填自定义值，对应 UDP 协议填另一值，方便接收端解封装时准确交付数据。
- 首部校验和：采用简单的校验算法，如 16 位的二进制反码求和，对分组首部进行校验，保障首部信息准确无误，若校验和错误，接收端可拒收或要求重发。
- 源 IP 地址与目的 IP 地址：设计符合网络规划的 IP 地址格式，可借鉴 IPv4 或 IPv6 的部分思路。若为小型封闭网络，采用较短的自定义 IP 地址，如 16 位，自行分配管理，降低地址管理复杂度；若考虑未来扩展性，预留足够的地址空间，类似 IPv6 采用较长位址格式。
路由算法选择与实现
- 静态路由：对于网络拓扑结构固定、节点较少的网络，如企业内部的专用机房网络，可人工配置静态路由表。网络管理员依据网络连接关系，为每个节点明确指定去往不同目的地的下一跳路由，优点是路由稳定、开销小，但缺乏灵活性，网络拓扑变化时需人工重新配置。
- 距离矢量路由：以 RIP（路由信息协议）为基础进行改进，每个节点周期性地向邻居节点广播自己到其他节点的距离（跳数）信息，邻居节点收到后，综合自身已有信息更新自身路由表。但要注意解决路由环路问题，可采用水平分割、毒性反转等技术，防止出现距离无限增大、分组在环路中循环的情况。
- 链路状态路由：类似 OSPF（开放最短路径优先），各节点首先收集自身与相邻节点间的链路状态信息（如链路带宽、延迟、可靠性等），然后将这些信息洪泛到整个网络，每个节点利用 Dijkstra 算法等最短路径算法计算出到其他节点的最优路径。这种算法适用于大型复杂网络，能快速适应网络拓扑变化，但计算量和信息传播量相对较大。

四、传输层自定义（类似 TCP 部分）

段格式设计
- 源端口与目的端口：与 TCP 相同，用于标识发送端和接收端的应用进程，端口号范围可遵循标准 TCP 的约定，0 - 1023 为系统保留端口，1024 - 65535 供应用程序自由使用，方便不同应用基于端口实现多路复用。
- 序列号：为每个传输段分配唯一序列号，用于保证数据有序接收与重组，尤其是在面对网络分片、乱序传输等情况时，接收端依序列号排列数据片段。序列号空间要足够大，避免短时间内循环，影响数据准确性判断。
- 确认号：用于接收端向发送端反馈已正确接收的数据位置，发送端据此了解接收情况，判断是否需要重发，与序列号配合实现可靠传输机制。
- 首部长度：明确段首部占字节数，便于接收端快速定位数据开始位置，因为不同的控制选项可能导致首部长度变化。
- 保留字段：预留部分字节，用于未来协议扩展，方便后续添加新功能，如适应新的网络应用需求或优化现有传输机制。
- 控制位：设置 URG（紧急指针有效）位，用于紧急数据传输；ACK（确认位）位，指示确认号是否有效；PSH（推送位）位，要求接收端尽快将数据交付应用程序，而非缓存；RST（复位位）位，用于异常情况下重置连接；SYN（同步位）位和 FIN（结束位）位，用于建立和结束连接，与 TCP 的连接管理机制类似，但可根据自定义需求优化同步、结束流程的细节。
- 窗口大小：发送端告知接收端自己当前的接收窗口大小，即能够接收的数据量，接收端据此调整发送速率，实现流量控制，防止发送端发送过多数据导致接收端溢出。
- 校验和：采用与 TCP 类似的校验和算法，对段内所有数据（包括首部和数据部分）进行校验，确保数据完整性，一旦校验和错误，接收端可要求发送端重发。
- 紧急指针：当 URG 位有效时，紧急指针指向紧急数据在段内的末尾位置，方便接收端优先处理紧急数据，满足特定应用对紧急信息的需求。
连接管理
- 三次握手：与 TCP 类似，发送端发送带有 SYN 位的段，初始序列号为随机值，接收端收到后回复带有 SYN + ACK 位的段，确认号为发送端序列号加 1，自身也生成随机序列号，发送端再发送带有 ACK 位的段，确认号为接收端序列号加 1，完成连接建立。但可优化握手过程的超时时间设置，根据网络延迟特性调整，减少因超时而不必要的重发。
- 连接维持：建立连接后，双方定期发送带有 ACK 位的段，确认对方存在，若长时间未收到对方确认，启动重连机制。同时，可根据网络负载、双方设备性能等因素动态调整确认间隔，在保障连接稳定的前提下，降低不必要的传输开销。
- 四次挥手：当一方要结束连接时，发送带有 FIN 位的段，对方收到后回复 ACK 位的段，然后反向发送带有 FIN 位的段，原发送端再回复 ACK 位的段，完成连接断开。在挥手过程中，同样可优化各环节的等待时间，如设置合理的 FIN_WAIT、TIME_WAIT 状态时长，适应不同网络场景。
可靠传输实现
- 基于序列号和确认号：发送端按序发送数据段，每发送一段，等待接收端确认。接收端收到数据段后，检查序列号，若正确则发送确认号为该序列号加 1 的确认段，若发现序列号不连续，说明有数据丢失或乱序，暂不确认，等待后续数据补齐或要求发送端重发。
- 重传机制：发送端设置超时定时器，若超时未收到确认，重发未确认的数据段。可采用自适应重传算法，根据网络往返延迟的历史数据动态调整超时时间，提高重传效率，避免频繁重发或因超时长时间等待。
- 滑动窗口机制：发送端根据接收端反馈的窗口大小，动态调整自己的发送窗口。如接收端窗口变小，发送端减少发送量；窗口变大，增加发送量，保证数据传输速率与接收端处理能力相匹配，同时结合序列号实现窗口内数据的有序传输与管理。

五、跨层优化与整合

数据链路层与网络层交互
- 当数据链路层检测到大量差错帧时，及时反馈给网络层，网络层可采取调整路由、降低发送速率等措施。例如，若某条链路差错率过高，网络层尝试选择其他备用路径，避免持续在低效链路上传输。
- 网络层分片操作与数据链路层帧大小适配。网络层依据数据链路层的帧承载能力合理分片，确保分片后的分组能顺利封装进帧，避免出现因分组过大无法封装或因分片过小浪费资源的情况。
网络层与传输层交互
- 传输层根据网络层反馈的网络拥塞状况（如 TTL 超时频繁、路由抖动等），调整自己的发送策略。在拥塞时，降低发送速率、缩小窗口大小，缓解网络压力；在网络畅通时，适当提高发送速率，充分利用网络资源。
- 网络层为传输层提供不同质量的服务路径选择。对于传输层标记的紧急数据或高优先级应用，网络层优先筛选低延迟、高可靠性的路径进行传输，保障关键数据及时、准确送达。

六、协议实现与测试

编程实现
- 选择合适的编程语言，如 C、C++，因其对底层硬件资源操控性强，适合实现网络协议这种对性能要求较高的系统。利用语言特性构建数据结构来表示各层协议单元，如结构体表示帧、分组、传输段等，成员变量对应各字段。
- 实现各层的核心功能函数，数据链路层包括帧的封装、解封、差错检测与处理、介质访问控制算法；网络层涵盖分组的组装、拆分、路由查找与转发；传输层有段的生成、连接管理流程、可靠传输逻辑等。通过函数调用与数据传递，将各层功能串联起来，形成完整的协议栈。
测试环境搭建
- 利用网络模拟器，如 NS2、NS3、OMNeT++ 等，创建虚拟网络环境，模拟不同网络拓扑（总线型、星型、网状等）、节点数量、链路特性（带宽、延迟、丢包率等），将自定义协议植入模拟网络中进行测试。
- 搭建物理测试平台，使用实际的网络设备（如路由器、交换机、无线接入点等）、服务器和终端设备，通过配置网络参数，构建小型真实网络，在实际场景下检验协议性能、稳定性与兼容性。
测试指标与方法
- 性能指标：测量吞吐量，即单位时间内成功传输的数据量，反映协议对网络资源的利用效率；计算延迟，包括端到端延迟、单程延迟，衡量数据传输快慢；统计丢包率，体现协议应对网络差错、拥塞的能力。
- 稳定性指标：长时间运行测试，观察协议栈是否出现死机、内存泄漏、异常连接中断等情况，确保在复杂网络条件下持续可靠运行。
- 兼容性指标：让采用自定义协议的设备与采用标准协议的设备共处同一网络，测试数据交互是否顺畅，能否协同工作，判断自定义协议对既有网络生态的适应性。

七、简单示例

以下是一个简化的示例代码，用于演示如何在 C# 中实现一个自定义的简单网络协议（涵盖了部分数据链路层、网络层和传输层类似功能的模拟，当然这只是一个非常基础且示意性的实现，距离真正完整可用的复杂网络协议还有很大差距，但可以帮助你理解基本的构建思路）。

1. 定义各层协议相关的数据结构

// 数据链路层帧结构
struct DataLinkFrame
{
    public byte[] startFlag; // 帧起始标志，假设为2字节
    public byte[] sourceAddress; // 源数据链路地址，假设为4字节
    public byte[] destinationAddress; // 目的数据链路地址，假设为4字节
    public byte[] controlField; // 控制字段，假设为1字节
    public byte[] data; // 数据字段，长度可变
    public byte[] checksum; // 校验和字段，假设为2字节
    public byte[] endFlag; // 帧结束标志，假设为2字节
}

// 网络层分组结构
struct NetworkPacket
{
    public byte[] version; // 版本号，假设为1字节
    public byte[] headerLength; // 首部长度，假设为1字节
    public byte[] serviceType; // 服务类型，假设为1字节
    public byte[] totalLength; // 总长度，假设为2字节
    public byte[] identifier; // 标识符，假设为2字节
    public byte[] flags; // 标志位，假设为1字节
    public byte[] fragmentOffset; // 片偏移，假设为2字节
    public byte[] ttl; // 生存时间，假设为1字节
    public byte[] protocol; // 协议类型，假设为1字节
    public byte[] headerChecksum; // 首部校验和，假设为2字节
    public byte[] sourceIP; // 源IP地址，假设自定义为4字节
    public byte[] destinationIP; // 目的IP地址，假设自定义为4字节
    public byte[] data; // 网络层数据，长度可变
}

// 传输层段结构（类似TCP段）
struct TransportSegment
{
    public ushort sourcePort; // 源端口号
    public ushort destinationPort; // 目的端口号
    public uint sequenceNumber; // 序列号
    public uint acknowledgmentNumber; // 确认号
    public byte[] headerLength; // 首部长度，假设为1字节
    public byte[] reserved; // 保留字段，假设为2字节
    public byte[] controlBits; // 控制位，假设为1字节
    public ushort windowSize; // 窗口大小
    public ushort checksum; // 校验和
    public ushort urgentPointer; // 紧急指针
    public byte[] data; // 传输层数据，长度可变
}

2. 数据链路层基本功能实现示例

class DataLinkLayer
{
    // 简单的帧封装方法示例（这里校验和等只是简单示意，实际要按严谨算法）
    public DataLinkFrame FrameEncapsulate(byte[] data, byte[] sourceAddress, byte[] destinationAddress)
    {
        DataLinkFrame frame = new DataLinkFrame();
        frame.startFlag = new byte[] { 0x7E, 0x7E }; // 简单的起始标志示例
        frame.sourceAddress = sourceAddress;
        frame.destinationAddress = destinationAddress;
        frame.controlField = new byte[] { 0x00 }; // 简单设置控制字段初始值
        frame.data = data;
        // 简单计算校验和（这里只是示例，实际要用合适算法如CRC等）
        frame.checksum = CalculateChecksum(frame.data); 
        frame.endFlag = new byte[] { 0x7E, 0x7E };
        return frame;
    }

    // 简单的帧解封方法示例
    public byte[] FrameDecapsulate(DataLinkFrame frame)
    {
        // 验证校验和等合法性（这里简单对比，实际要严谨判断）
        if (VerifyChecksum(frame.data, frame.checksum))
        {
            return frame.data;
        }
        return null;
    }

    private byte[] CalculateChecksum(byte[] data)
    {
        // 简单求和取反作为校验和示例（非常不严谨，仅示意）
        int sum = 0;
        for (int i = 0; i < data.Length; i++)
        {
            sum += data[i];
        }
        return BitConverter.GetBytes((ushort)~sum);
    }

    private bool VerifyChecksum(byte[] data, byte[] checksum)
    {
        byte[] calculatedChecksum = CalculateChecksum(data);
        return calculatedChecksum.SequenceEqual(checksum);
    }
}

3. 网络层基本功能实现示例

class NetworkLayer
{
    // 分组封装示例
    public NetworkPacket PacketEncapsulate(byte[] data, byte[] sourceIP, byte[] destinationIP)
    {
        NetworkPacket packet = new NetworkPacket();
        packet.version = new byte[] { 0x01 }; // 版本号示例
        packet.headerLength = new byte[] { 0x05 }; // 假设首部长度值示例
        packet.serviceType = new byte[] { 0x00 }; // 服务类型初始示例
        packet.totalLength = BitConverter.GetBytes((ushort)(data.Length + 20)); // 假设首部固定20字节，计算总长度
        packet.identifier = new byte[] { 0x00, 0x00 }; // 标识符示例
        packet.flags = new byte[] { 0x00 }; // 标志位示例
        packet.fragmentOffset = new byte[] { 0x00, 0x00 }; // 片偏移示例
        packet.ttl = new byte[] { 0x10 }; // 生存时间示例
        packet.protocol = new byte[] { 0x01 }; // 假设对应传输层自定义协议类型值
        packet.headerChecksum = CalculateHeaderChecksum(packet); // 计算首部校验和
        packet.sourceIP = sourceIP;
        packet.destinationIP = destinationIP;
        packet.data = data;
        return packet;
    }

    // 分组解封示例
    public byte[] PacketDecapsulate(NetworkPacket packet)
    {
        if (VerifyHeaderChecksum(packet))
        {
            return packet.data;
        }
        return null;
    }

    private byte[] CalculateHeaderChecksum(NetworkPacket packet)
    {
        // 简单的16位二进制反码求和计算首部校验和示例（不严谨，实际更复杂）
        int sum = 0;
        byte[] headerBytes = GetHeaderBytes(packet);
        for (int i = 0; i < headerBytes.Length; i += 2)
        {
            ushort value = BitConverter.ToUInt16(headerBytes, i);
            sum += value;
            if ((i + 2) < headerBytes.Length)
            {
                sum += (sum >> 16);
                sum &= 0xFFFF;
            }
        }
        return BitConverter.GetBytes((ushort)~sum);
    }

    private bool VerifyHeaderChecksum(NetworkPacket packet)
    {
        byte[] calculatedChecksum = CalculateHeaderChecksum(packet);
        return calculatedChecksum.SequenceEqual(packet.headerChecksum);
    }

    private byte[] GetHeaderBytes(NetworkPacket packet)
    {
        List<byte> headerBytes = new List<byte>();
        headerBytes.AddRange(packet.version);
        headerBytes.AddRange(packet.headerLength);
        headerBytes.AddRange(packet.serviceType);
        headerBytes.AddRange(packet.totalLength);
        headerBytes.AddRange(packet.identifier);
        headerBytes.AddRange(packet.flags);
        headerBytes.AddRange(packet.fragmentOffset);
        headerBytes.AddRange(packet.ttl);
        headerBytes.AddRange(packet.protocol);
        headerBytes.AddRange(packet.headerChecksum);
        headerBytes.AddRange(packet.sourceIP);
        headerBytes.AddRange(packet.destinationIP);
        return headerBytes.ToArray();
    }
}

4. 传输层基本功能实现示例

class TransportLayer
{
    // 段封装示例
    public TransportSegment SegmentEncapsulate(byte[] data, ushort sourcePort, ushort destinationPort, uint sequenceNumber, uint acknowledgmentNumber)
    {
        TransportSegment segment = new TransportSegment();
        segment.sourcePort = sourcePort;
        segment.destinationPort = destinationPort;
        segment.sequenceNumber = sequenceNumber;
        segment.acknowledgmentNumber = acknowledgmentNumber;
        segment.headerLength = new byte[] { 0x05 }; // 假设首部长度示例
        segment.reserved = new byte[] { 0x00, 0x00 }; // 保留字段示例
        segment.controlBits = new byte[] { 0x00 }; // 控制位示例
        segment.windowSize = 1024; // 窗口大小示例
        segment.checksum = CalculateChecksum(segment, data);
        segment.urgentPointer = 0; // 紧急指针示例
        segment.data = data;
        return segment;
    }

    // 段解封示例
    public byte[] SegmentDecapsulate(TransportSegment segment)
    {
        if (VerifyChecksum(segment, segment.data))
        {
            return segment.data;
        }
        return null;
    }

    private ushort CalculateChecksum(TransportSegment segment, byte[] data)
    {
        // 简单计算校验和示例（将首部和数据一起参与计算）
        List<byte> combinedBytes = new List<byte>();
        combinedBytes.AddRange(BitConverter.GetBytes(segment.sourcePort));
        combinedBytes.AddRange(BitConverter.GetBytes(segment.destinationPort));
        combinedBytes.AddRange(BitConverter.GetBytes(segment.sequenceNumber));
        combinedBytes.AddRange(BitConverter.GetBytes(segment.acknowledgmentNumber));
        combinedBytes.AddRange(segment.headerLength);
        combinedBytes.AddRange(segment.reserved);
        combinedBytes.AddRange(segment.controlBits);
        combinedBytes.AddRange(BitConverter.GetBytes(segment.windowSize));
        combinedBytes.AddRange(BitConverter.GetBytes(0)); // 校验和初始设为0
        combinedBytes.AddRange(BitConverter.GetBytes(segment.urgentPointer));
        combinedBytes.AddRange(data);
        int sum = 0;
        for (int i = 0; i < combinedBytes.Count; i += 2)
        {
            ushort value = BitConverter.ToUInt16(combinedBytes, i);
            sum += value;
            if ((i + 2) < combinedBytes.Count)
            {
                sum += (sum >> 16);
                sum &= 0xFFFF;
            }
        }
        return (ushort)~sum;
    }

    private bool VerifyChecksum(TransportSegment segment, byte[] data)
    {
        ushort calculatedChecksum = CalculateChecksum(segment, data);
        return calculatedChecksum == segment.checksum;
    }
}

5. 简单使用示例

class Program
{
    static void Main()
    {
        byte[] sourceAddress = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        byte[] destinationAddress = new byte[] { 0x05, 0x06, 0x07, 0x08 };
        byte[] sourceIP = new byte[] { 0x10, 0x11, 0x12, 0x13 };
        byte[] destinationIP = new byte[] { 0x14, 0x15, 0x16, 0x17 };

        byte[] applicationData = Encoding.UTF8.GetBytes("Hello, Custom Protocol!");

        // 数据链路层封装
        DataLinkLayer dataLinkLayer = new DataLinkLayer();
        DataLinkFrame frame = dataLinkLayer.FrameEncapsulate(applicationData, sourceAddress, destinationAddress);

        // 网络层封装
        NetworkLayer networkLayer = new NetworkLayer();
        NetworkPacket packet = networkLayer.PacketEncapsulate(frame.data, sourceIP, destinationIP);

        // 传输层封装
        TransportLayer transportLayer = new TransportLayer();
        TransportSegment segment = transportLayer.SegmentEncapsulate(packet.data, 1000, 2000, 1, 0);

        // 模拟接收端，按相反顺序解封
        byte[] receivedData = transportLayer.SegmentDecapsulate(segment);
        if (receivedData!= null)
        {
            NetworkPacket receivedPacket = networkLayer.PacketDecapsulate(DeserializeNetworkPacket(receivedData));
            if (receivedPacket!= null)
            {
                byte[] receivedFrameData = dataLinkLayer.FrameDecapsulate(DeserializeDataLinkFrame(receivedPacket.data));
                if (receivedFrameData!= null)
                {
                    string message = Encoding.UTF8.GetString(receivedFrameData);
                    Console.WriteLine(message);
                }
            }
        }
    }

    private static NetworkPacket DeserializeNetworkPacket(byte[] data)
    {
        // 简单反序列化网络分组示例（实际要更严谨处理字节序等）
        NetworkPacket packet = new NetworkPacket();
        packet.version = new byte[] { data[0] };
        packet.headerLength = new byte[] { data[1] };
        packet.serviceType = new byte[] { data[2] };
        packet.totalLength = new byte[] { data[3], data[4] };
        packet.identifier = new byte[] { data[5], data[6] };
        packet.flags = new byte[] { data[7] };
        packet.fragmentOffset = new byte[] { data[8], data[9] };
        packet.ttl = new byte[] { data[10] };
        packet.protocol = new byte[] { data[11] };
        packet.headerChecksum = new byte[] { data[12], data[13] };
        packet.sourceIP = new byte[] { data[14], data[15], data[16], data[17] };
        packet.destinationIP = new byte[] { data[18], data[19], data[20], data[21] };
        packet.data = new byte[data.Length - 22];
        Array.Copy(data, 22, packet.data, 0, packet.data.Length);
        return packet;
    }

    private static DataLinkFrame DeserializeDataLinkFrame(byte[] data)
    {
        // 简单反序列化数据链路帧示例（实际要更严谨处理）
        DataLinkFrame frame = new DataLinkFrame();
        frame.startFlag = new byte[] { data[0], data[1] };
        frame.sourceAddress = new byte[] { data[2], data[3], data[4], data[5] };
        frame.destinationAddress = new byte[] { data[6], data[7], data[8], data[9] };
        frame.controlField = new byte[] { data[10] };
        frame.data = new byte[data.Length - 13];
        Array.Copy(data, 11, frame.data, 0, frame.data.Length);
        frame.checksum = new byte[] { data[data.Length - 3], data[data.Length - 2] };
        frame.endFlag = new byte[] { data[data.Length - 1], data[data.Length] };
        return frame;
    }
}

请注意：

上述代码中的校验和计算等相关算法只是非常简单的示意，实际应用中需要按照标准且严谨的算法（如 CRC 校验、标准的 IP 首部校验和算法等）来准确计算，以保障数据的完整性和正确性。
路由、连接管理、可靠传输等更复杂的功能只是在理论层面提及了部分实现思路，代码中并没有完整地、实际可用地体现，若要完善这些功能，还需要大量更细致的代码逻辑来实现，比如实现路由表的维护、三次握手、重传机制等。
这里的示例只是基于自定义协议的基本结构搭建了一个简单的收发流程，在真实的网络环境中，还需要考虑如何与底层网络接口（如网卡驱动等）交互，以及处理多线程并发、网络拥塞等诸多实际问题。

八、总结与展望

通过从数据链路层到传输层对网络协议的自定义构建，能够满足多样化的网络需求。在实际应用中，不断优化协议各环节，根据测试反馈改进设计缺陷，可逐步提升协议性能与适应性。随着未来网络技术的发展，如量子通信、物联网、工业互联网的兴起，自定义网络协议将有更广阔的空间，不断融合新兴技术，向着更高性能、更强安全性、更优适配性的方向持续进化，为各类前沿网络应用提供坚实支撑。

标签：自定义,示例,网络协议,packet,假如,new,byte,data,public
From： https://blog.csdn.net/m0_60315436/article/details/144978624