【IP层的校验和与UDP的校验和】+【FPGA实现】

已于 2024-04-09 12:54:38 修改
阅读量891 收藏 13
点赞数 6
分类专栏： 以太网 FPGA学习 读书笔记 文章标签： fpga开发
于 2024-04-08 15:05:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NoNoUnknow/article/details/137509933
版权

IP头校验和

IP头校验和是一种错误检测机制，用于在互联网协议（IP）中保证IP头的数据完整性。

当一个IP数据包从源主机发送到目的主机时，它经过许多路由器和交换机，校验和可以帮助这些中间设备检查数据包在传输过程中是否出现错误。

IP头校验和的计算方式如下：

  1. 分割：将IP头部分为16位（2字节）的段。
  2. 求和：将所有16位的段相加（以二进制求和，也就是每个段直接按位相加）。
  3. 进位处理：如果求和的结果产生了溢出，则将溢出的部分（即进位）加到求和的结果的最低位上。这可能需要重复进行，直到不再有溢出发生。
  4. 取反：将求和结果取反（按位取反，1变0，0变1）得到校验和。

这个校验和随后被填充在IP头中专门为校验和预留的字段内。在接收端，同样的计算会被执行在收到的IP头上，包括校验和字段本身。如果数据包在传输过程中没有错误，所有段的总和加上接收到的校验和的结果应该是一个全1的二进制数（因为原始计算中结果取反了）。如果计算结果不是全1，那么就说明数据在传输过程中可能出现了错误。

重要的是，IP头校验和只检查头部的完整性，并不保护整个IP数据包的内容。传输层（如TCP或UDP）有自己的校验和，负责整个数据段（包括数据）的完整性检查。

在实际的网络设备中，这个计算通常是由硬件来执行，以提高数据包处理的效率。当数据包通过每个路由器传输时，因为TTL字段会改变，所以需要重新计算校验和。

module emcode_checksum_ip #(
    parameter   Length_HeartBeat_all = 8'd114
)(
    input   wire            sys_clk            ,
    input   wire            sys_rst_n          ,
    input   wire            i_vaild            ,
    input   wire  [7:0]     i_data             ,
    output  wire            o_vaild            ,
    output  wire  [7:0]     o_data                   
);
            reg   [15:0]    r_i_vaild          ;
            reg   [07:0]    r1_i_data  [15:0]  ;

            reg   [07:0]    checksum_cnt       ;
            reg   [01:0]    concat_cnt         ;
            wire  [15:0]    concat_data        ;
            reg   [31:0]    r1_sum             ;
            wire  [31:0]    r1_checksum_value  ;
            wire  [15:0]    r2_checksum_value  ;
            reg   [15:0]    r3_checksum_value  ;
            reg   [07:0]    vaild_cnt          ;
            reg   [07:0]    r_o_data           ;

    always @(posedge sys_clk) begin
        r_i_vaild <= {r_i_vaild[14:0],i_vaild};
    end

    reg [7:0] reg_i1;
    reg [7:0] reg_i2;
    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            for (reg_i1 = 0; reg_i1 < 'd15;  reg_i1 = reg_i1 + 1) begin
                r1_i_data[reg_i1] <= 'd0;
            end
        end else begin
            for (reg_i2 = 0; reg_i2 < 'd15;  reg_i2 = reg_i2 + 1) begin
                r1_i_data[reg_i2+1] <= r1_i_data[reg_i2];
            end
            r1_i_data[0] <= i_data;
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            checksum_cnt <= 8'h0;
        end else if(i_vaild == 1'b0 && r_i_vaild[0] == 1'b1) begin
            checksum_cnt <= 8'h0;
        end else if(i_vaild == 1'b1)begin
            checksum_cnt <= checksum_cnt + 1'b1;
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            vaild_cnt <= 8'h0;
        end else if(r_i_vaild[10] == 1'b0 && r_i_vaild[11] == 1'b1) begin
            vaild_cnt <= 8'h0;
        end else if(r_i_vaild[10] == 1'b1)begin
            vaild_cnt <= vaild_cnt + 1'b1;
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            concat_cnt <= 2'd0;
        end else if(i_vaild == 1'b0 && r_i_vaild[0] == 1'b1) begin
            concat_cnt <= 2'd0;
        end else if(i_vaild == 1'b1 && checksum_cnt >= 'd22 && checksum_cnt <= 41) begin
            if(concat_cnt == 1'b1) begin
                concat_cnt <= 2'd0;
            end else begin
                concat_cnt <= concat_cnt + 1'b1;
            end
        end else begin
            concat_cnt <= concat_cnt;
        end
    end

    assign  concat_data = {r1_i_data[0],i_data};

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            r1_sum <= 32'd0;
        end else if(i_vaild == 1'b0 && r_i_vaild[0] == 1'b1) begin
            r1_sum <= 32'd0;
        end else if(i_vaild == 1'b1 && checksum_cnt >= 'd22 && checksum_cnt <= 'd41 && concat_cnt == 1'b1) begin
            r1_sum <= r1_sum + concat_data;
        end else begin
            r1_sum <= r1_sum;
        end
    end    

    assign  r1_checksum_value =  r1_sum[15:0] + r1_sum[31:16];
    assign  r2_checksum_value = ~(r1_checksum_value[15:0]);

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            r3_checksum_value <= 'd0;
        end else if(r_i_vaild[10] == 1'b0 && r_i_vaild[11] == 1'b1) begin
            r3_checksum_value <= 'd0;
        end else if(i_vaild == 1'b1 && checksum_cnt == 'd42) begin
            r3_checksum_value <= r2_checksum_value;
        end
    end

    assign  o_vaild = r_i_vaild[11];
    assign  o_data  = r_o_data     ;
    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            r_o_data <= 8'd0;
        end else if(r_i_vaild[10] == 1'b1 && vaild_cnt == 'd32) begin
            r_o_data <= r3_checksum_value[15:08];
        end else if(r_i_vaild[10] == 1'b1 && vaild_cnt == 'd33) begin
            r_o_data <= r3_checksum_value[07:00];
        end else begin
            r_o_data <= r1_i_data[10];
        end
    end
endmodule

UDP校验和

UDP校验和是一种错误检测机制，与IP校验和类似，但它覆盖了更多的数据：UDP校验和不仅检查UDP头部，还检查数据部分。这为UDP数据包提供了一个简单的形式的数据完整性验证。

计算UDP校验和的步骤如下：

  1. 伪头部：首先，创建一个所谓的“伪头部”，它包括源IP地址、目的IP地址、一个8位全零字段、协议字段（对于UDP，这个值是17，8‘h11）和UDP长度字段。这个伪头部不是UDP数据包的一部分，而是仅用于校验和计算过程。

  2. 合并：将伪头部、UDP头部和数据部分合并起来。如果数据的总字节长度不是偶数，会在最后添加一个零字节来填充。

  3. 分割：将合并后的数据分割成16位的段。

  4. 求和：以二进制求和这些16位的段，包括溢出。

  5. 进位处理：与IP校验和相同，如果求和的结果产生溢出，将溢出的部分加回到求和结果的最低位。

  6. 取反：将最终的求和结果取反。

得到的校验和随后放入UDP头部中的校验和字段。在接收端，同样的计算会被执行在整个数据包上（包括伪头部）。如果数据包传输正确，所有的16位段相加（包括校验和字段）应该结果为全1的二进制数（0xFFFF）。如果不是，那么就说明数据包在传输过程中出现了错误。

值得注意的是，UDP校验和是可选的，在IPv4中可以设置为零表示不计算校验和，但在IPv6中，UDP校验和是必需的。这是因为IPv6不包括一个独立的校验和，因此依赖于UDP校验和提供错误检测。

module checksum_ip_buffer #(
    parameter   UDP_CODE             =  8'h11                                           ,
    parameter   TX_TARGET_PORT       = 16'd808                                          ,
    parameter   TX_SOURCE_PORT       = 16'd8080                                         ,
    parameter   RX_Sync_Frame        = 32'hF05AA50F                                     ,
    parameter   TX_SOURCE_Addr       = {8'd192,8'd168,8'd0,8'd1}                        ,
    parameter   TX_TARGET_Addr       = {8'hFF,8'hFF,8'hFF,8'hFF}                        ,
    //Length
    parameter   TX_PREAMBLE          = {8'h55,8'h55,8'h55,8'h55,8'h55,8'h55,8'h55,8'hD5},
    parameter   TX_TARGET_MAC        = {8'hFF,8'hFF,8'hFF,8'hFF,8'hFF,8'hFF}            ,// broadcast packet
    parameter   TX_SOURECE_MAC       = {8'hA8,8'hB2,8'h3C,8'h7D,8'h97,8'hD7}            , 
    parameter   Length_HeartBeat     = 16'd92                                           ,
    parameter   Length_UDP           = 16'd72                                           ,
    parameter   Length_HeartBeat_all = 8'd114                                           ,
    parameter   Length_EnCODE_Packet = 8'd114 
)(
    input   wire            sys_clk            ,
    input   wire            sys_rst_n          ,
    input   wire            i_vaild            ,
    input   wire  [7:0]     i_data             ,
    output  wire            o_vaild            ,
    output  wire  [7:0]     o_data                   
);
            reg   [15:0]    i_vaild_cnt          ;
            reg   [15:0]    r_i_vaild            ;
            reg   [07:0]    r1_i_data            ;
            wire  [15:0]    concat_data          ;
        //IP check sum
            reg   [01:0]    ip_concat_cnt        ;
            reg   [01:0]    udp_concat_cnt       ;
            reg   [31:0]    r1_IPsum             ;
            wire  [31:0]    r1_IPchecksum_value  ;
            reg   [15:0]    r2_IPchecksum_value  ;

        //UDP check sum
            reg             udp_reg              ;
            reg   [31:0]    r1_UDPsum            ;
            wire  [31:0]    r1_UDPchecksum_value ;
            wire  [15:0]    r2_UDPchecksum_value ;
            reg   [15:0]    r3_UDPchecksum_value ;
            //rd
            reg             rd_cycle             ;
            reg   [15:0]    rd_cnt               ;
            reg   [15:0]    r_rd_cnt             ;
            reg             r1_o_vaild           ;
            reg             r2_o_vaild           ;
            reg   [07:0]    r1_o_data            ;
            wire  [07:0]    rd_data              ;
            wire  [31:00]   Faker_header         ;
            wire  [15:00]   length_check         ;
            wire            length_check_flag    ;

    assign  Faker_header    = TX_SOURCE_Addr[31:16] + TX_SOURCE_Addr[15:00]
                            + TX_TARGET_Addr[31:16] + TX_TARGET_Addr[15:00]
                            + {8'h00,UDP_CODE} + Length_UDP;

    assign  length_check = Length_UDP - 'd8;
    assign  length_check_flag = (length_check[0] == 0)?(1'b0):(1'b1);


    always @(posedge sys_clk) begin
        r_i_vaild <= {r_i_vaild[14:0],i_vaild};
        r1_o_vaild <= rd_cycle;
        r2_o_vaild <= r1_o_vaild;
        r1_i_data  <= i_data;
        r_rd_cnt   <= rd_cnt;
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            i_vaild_cnt <= 8'h0;
        end else if(i_vaild == 1'b1) begin
            if(i_vaild_cnt == Length_EnCODE_Packet - 1'b1) begin
                i_vaild_cnt <= 8'h0;
            end else begin
                i_vaild_cnt <= i_vaild_cnt + 1'b1;
            end
        end
    end

    assign  concat_data = {r1_i_data,i_data};

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            ip_concat_cnt <= 2'd0;
        end else if(i_vaild == 1'b0 && r_i_vaild[0] == 1'b1) begin
            ip_concat_cnt <= 2'd0;
        end else if(i_vaild == 1'b1 && i_vaild_cnt >= 'd22 && i_vaild_cnt <= 41) begin
            if(ip_concat_cnt == 1'b1) begin
                ip_concat_cnt <= 2'd0;
            end else begin
                ip_concat_cnt <= ip_concat_cnt + 1'b1;
            end
        end else begin
            ip_concat_cnt <= ip_concat_cnt;
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            r1_IPsum <= 32'd0;
        end else if(i_vaild == 1'b0 && r_i_vaild[0] == 1'b1) begin
            r1_IPsum <= 32'd0;
        end else if(i_vaild == 1'b1 && i_vaild_cnt >= 'd22 && i_vaild_cnt <= 'd41 && ip_concat_cnt == 1'b1) begin
            r1_IPsum <= r1_IPsum + concat_data;
        end else begin
            r1_IPsum <= r1_IPsum;
        end
    end 

    assign  r1_IPchecksum_value =  r1_IPsum[15:0] + r1_IPsum[31:16];

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            r2_IPchecksum_value <= 'd0;
        end else if(rd_cycle == 1'b1 && rd_cnt == Length_EnCODE_Packet - 1'b1) begin
            r2_IPchecksum_value <= 'd0;
        end else if(i_vaild == 1'b1 && i_vaild_cnt == 'd42) begin
            r2_IPchecksum_value <= ~(r1_IPchecksum_value[15:0]);
        end
    end

// UDP
    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            udp_concat_cnt <= 2'd0;
        end else if(i_vaild == 1'b0 && r_i_vaild[0] == 1'b1) begin
            udp_concat_cnt <= 2'd0;
        end else if(i_vaild == 1'b1 && ((i_vaild_cnt >= 42 && i_vaild_cnt <= 49) 
        || (i_vaild_cnt >= 'd50 && i_vaild_cnt <= Length_EnCODE_Packet - 1'b1))) begin
            if(udp_concat_cnt == 1'b1) begin
                udp_concat_cnt <= 2'd0;
            end else begin
                udp_concat_cnt <= udp_concat_cnt + 1'b1;
            end
        end else begin
            udp_concat_cnt <= udp_concat_cnt;
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            udp_reg <= 1'b0;
        end else if(i_vaild == 1'b1 && i_vaild_cnt == Length_EnCODE_Packet - 1'b1) begin
            udp_reg <= 1'b1;
        end else begin
            udp_reg <= 1'b0;
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            r1_UDPsum <= 'd0;
        end else if(rd_cycle == 1'b1 && rd_cnt == Length_EnCODE_Packet - 1'b1) begin
            r1_UDPsum <= 'd0;
        end else if(i_vaild == 1'b1 && r_i_vaild == 1'b0) begin
            r1_UDPsum <= Faker_header;
        end else if(i_vaild == 1'b1 && udp_concat_cnt == 1'b1 
        && ((i_vaild_cnt >= 'd42 && i_vaild_cnt <= 'd49) 
        ||  (i_vaild_cnt >= 'd50 && i_vaild_cnt <= Length_EnCODE_Packet - 1'b1))) begin
            r1_UDPsum <= r1_UDPsum + concat_data;
        end else begin
            r1_UDPsum <= r1_UDPsum;
        end
    end 

    assign  r1_UDPchecksum_value =  r1_UDPsum[15:0] + r1_UDPsum[31:16];
    assign  r2_UDPchecksum_value = ~(r1_UDPchecksum_value[15:0]);

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            r3_UDPchecksum_value <= 'd0;
        end else if(rd_cycle == 1'b1 && rd_cnt == Length_EnCODE_Packet - 1'b1) begin
            r3_UDPchecksum_value <= 'd0;
        end else if(udp_reg == 1'b1) begin
            r3_UDPchecksum_value <= r2_UDPchecksum_value;
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            rd_cycle <= 1'b0;
        end else if(rd_cycle == 1'b1 && rd_cnt == Length_EnCODE_Packet - 1'b1) begin
            rd_cycle <= 1'b0;
        end else if(rd_cycle == 1'b0 && i_vaild == 1'b1 && i_vaild_cnt == Length_EnCODE_Packet - 1'b1) begin
            rd_cycle <= 1'b1;
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            rd_cnt <= 8'h0;
        end else if(rd_cycle == 1'b1) begin
            if(rd_cnt == Length_EnCODE_Packet - 1'b1) begin
                rd_cnt <= 8'h0;
            end else begin
                rd_cnt <= rd_cnt + 1'b1;
            end
        end
    end

    always @(posedge sys_clk) begin
        if(sys_rst_n == 1'b0) begin
            r1_o_data <= 8'h0;
        end else if(r1_o_vaild == 1'b1 && r_rd_cnt == 'd32) begin
            r1_o_data <= r2_IPchecksum_value[15:08];
        end else if(r1_o_vaild == 1'b1 && r_rd_cnt == 'd33) begin
            r1_o_data <= r2_IPchecksum_value[07:00];
        end else if(r1_o_vaild == 1'b1 && r_rd_cnt == 'd48) begin
            r1_o_data <= r3_UDPchecksum_value[15:08];
        end else if(r1_o_vaild == 1'b1 && r_rd_cnt == 'd49) begin
            r1_o_data <= r3_UDPchecksum_value[07:00];
        end else if(r1_o_vaild == 1'b1) begin
            r1_o_data <= rd_data;
        end else begin
            r1_o_data <= 8'hff;
        end
    end

    assign  o_vaild  = r2_o_vaild;
    assign  o_data   = r1_o_data;


buffer_encode buffer_encode_inst0 (
  .clka ( sys_clk     ), // input wire clka
  .wea  ( i_vaild     ), // input wire [0 : 0] wea
  .addra( i_vaild_cnt ), // input wire [6 : 0] addra
  .dina ( i_data      ), // input wire [7 : 0] dina
  .clkb ( sys_clk     ), // input wire clkb
  .addrb( rd_cnt      ), // input wire [6 : 0] addrb
  .doutb( rd_data     )  // output wire [7 : 0] doutb
);

endmodule

ip头校验和
Wait for 的专栏
06-28 5510
在巨著《TCP/IP详解1》中有这样一句话：“ICMP,IGMP,UDP and TCP all use the same checksum algorithm”。的确，检验和算法在TCP/IP协议族中大同小异。其过程大致都是：接收方通过判断检验和是否一致，进一步判断该数据包头部传输过程中是否丢失或者被污染了。本文将以IP协议首部（见下图）为例简单介绍检验和算法：
千兆通信中发送链路的 IP 和 UDP 校验和计算
qq_45565330的博客
11-10 1120
千兆通信中发送链路的 IP 和 UDP 校验和计算
IP头校验和计算
11-24
用户填写IP头信息，点击计算校验和能得出校验和的值，可以配合抓包工具使用，校验比较一致。
IP数据报首部校验和算法 详细 非代码
weixin_33860147的博客
10-18 1507
当用google搜索IP数据报首部校验和算法的时候，总是看到的是代码，没有看到其过程，于是就有了此文，如有错误请指正。文章省略一点，呵呵 IP/ICMP/IGMP/TCP/UDP等协议的校验和算法都是相同的，算法如下： 在发送数据时，为了计算数IP据报的校验和。应该按如下步骤： （1）把IP数据报的首部都置为0，包括校验和字段。 （2）把首部看成以16位为单位的数字组成，依次进...
IP校验和原理和Verilog实现
最新发布
weixin_57739513的博客
08-29 572
在进行基于FPGA开发千兆以太网UDP通信时，发现所给例程使用的IP校验和，很多存在使用过多的组合逻辑，导致数据路径太长，在高频率时钟下很容易引起时序违例。因此专门写了一个ip_checksum模块，进行计算IP校验和。
IP校验和详解
robertzhouxh的专栏
11-02 2875
一、校验和算法    之前一直只知道IP校验和算法反码求和相关的,但具体细节不清楚,今天了解了下。    IP校验和主要是用来保证数据(IP包头)的完整性的.它用的算法非常简单,就是反码求和校验.需要注意的是反码求和又叫1的补码(one'scomplement),而2的补码就是我们通常说的补码求和了.校验算法具体如下. 1、发送方    i)将校验和字段置为0,
IP的头部校验和
LDF-Dicky的博客
07-15 1万+
IP的头部校验和是用来检测IP头部的完整性和正确性 发送方在数据封装过程中会通过一套奇偶校验和算法对IP头部进行计算，之后得出一个校验值，将其置入IP头部中； 当接收方收到此数据包时，又会通过校验算法对IP头部进行计算 此时将得出的校验和与发送方的校验值对比，如果发现不是全1的话，说明这个分组有问题，此时便可以将其丢弃；相反，如果一致的话，此时正常处理. “为了计算一份数据报的 IP检
FPGA实现UDP协议（包括ARP、ICMP）
05-19
- **错误检测与处理**：在数据传输过程中，需要检查校验和，确保数据的完整性。 - **内存管理**：在接收和发送数据时，可能需要使用BRAM（Block RAM）或分布式RAM存储数据包。 - **并行处理**：FPGA的优势在于并行...
qianzhaowang.rar_arp_fpga 以太网_fpga arp_fpga实现udp_udp fpga实现
09-23
在本项目中，我们关注的是基于FPGA（Field-Programmable Gate Array）实现的以太网通信，特别是ARP（Address Resolution Protocol）和UDP（User Datagram Protocol）的硬件实现。以下将详细介绍这两个协议以及如何在...
千兆以太网传输层 UDP 协议原理与 FPGA 实现（UDP发送）
小王在努力...的博客
09-22 2798
本章将讲解千兆以太网传输层 UDP 协议的相关内容。学习 UDP 层协议的内容，核心也是明确该协议的数据字段格式。在此基础上，理解其“不可靠、无连接”的传输特性。同时，结合前面章节的内容，进一步深化理解用户数据、UDP、IP、MAC 层的层层打包嵌套关系。
udp_sometimez2k_TCPUDp_fpga实现udp_UDP_fpga_
10-02
3. **TCP/IP协议栈的理解**：虽然主要关注UDP，但理解TCP/IP协议栈的整体架构对于在FPGA上实现网络功能至关重要，因为UDP通常是在IP层之上运行。 4. **仿真与验证**：使用仿真工具（如ModelSim、Vivado等）进行功能...
udp校验和计算
12-27
udp校验和，基于wireshark的TCP和UDP报文分析
UDP校验和计算工具
11-03
使用Java开发的UDP校验和，将完整的UDP报文黏贴进去，计算出对应的UDP校验和
ip首部校验和
CSDN_of_ding的博客
09-02 2662
ip首部校验和 只检验数据报的首部，不包括数据部分 方法： 在发送方，先把IP数据报首部划分为许多16位字的序列，并把检验和字段置0，用反码算术运算把所有16位字相加后，将得到的和的反码写入检验和字段。 接收方收到数据报后，将首部的所有16位字再使用反码算术运算相加一次。将得到的和取反码，即得出接收方的检验和的计算结果。 若首部未发生任何变化，则此结果必为0。 UDP校验和 与IP校验和类似，但UDP的检验和是把首部和数据部分一起都检验。 *在计算检验和时，要在UDP用户数据报之前增加12字节的伪首部。 方
IP协议头校验和
pcd的博客
08-14 9710
在IPv4协议中，首部检验和占16位。这个字段只检验数据报的首部，但不包括数据部分。这是因为数据报每经过一个路由器，路由器都要重新计算一下首部检验和（一些字段，如生存 时间、标志、片偏移等都可能发生变化）。不检验数据部分可减少计算的工作量。 IP首部的检验和采用下面的简单计算方法：在发送方，先把IP数据报首部划分为许多16位字的序列，并把检验和字段置 零。用反码算术运算把所有16位字相加后，将得...
IP首部校验和算法
技术心得
07-04 1613
IP数据报首部校验和(长度是16位），用于检验首部的有效性和完整性。IP首部校验和采用 的时反码求和算法。就是把首部看成16位的整数序列。然后反码求和。把 得到的值放入首部校验和位置。反码求和算法如下： 0和0相加是0但要产生一个进位1，0和1相加是1，1和1相加是0．若最高位相加后产生进位， 则最后得到的结果要加1。 （0）反 + （0）反 = 1 + 1
如何计算IP首部校验和Header CheckSum（计算详解、代码解析、例子）
热门推荐
染落林间色的博客
10-26 1万+
首部校验和是在网络通信中常用的一种校验方法，用于验证数据包在传输过程中是否出现了错误或损坏。通常应用于网络层协议（如IP协议）的首部中。
IP校验和（checksum）原理
weixin_28673511的博客
04-24 3594
IP头部校验和原理，原始套接字自行组包用到，附带示例。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值