VirtualBox

Changeset 11013 in vbox for trunk/src/VBox/Runtime


Ignore:
Timestamp:
Jul 30, 2008 7:31:51 PM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
33892
Message:

iprt/net: iSum -> u32Sum since it's kind of important that this intermediate value really is 32-bit.include

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Runtime/common/checksum/ipv4.cpp

    r11012 r11013  
    4747{
    4848    uint16_t const *paw = (uint16_t const *)pIpHdr;
    49     int32_t iSum = paw[0]               /* ip_hl */
    50                  + paw[1]               /* ip_len */
    51                  + paw[2]               /* ip_id */
    52                  + paw[3]               /* ip_off */
    53                  + paw[4]               /* ip_ttl */
    54                  /*+ paw[5] == 0 */     /* ip_sum */
    55                  + paw[6]               /* ip_src */
    56                  + paw[7]               /* ip_src:16 */
    57                  + paw[8]               /* ip_dst */
    58                  + paw[9];              /* ip_dst:16 */
     49    uint32_t u32Sum = paw[0]            /* ip_hl */
     50                    + paw[1]            /* ip_len */
     51                    + paw[2]            /* ip_id */
     52                    + paw[3]            /* ip_off */
     53                    + paw[4]            /* ip_ttl */
     54                    /*+ paw[5] == 0 */  /* ip_sum */
     55                    + paw[6]            /* ip_src */
     56                    + paw[7]            /* ip_src:16 */
     57                    + paw[8]            /* ip_dst */
     58                    + paw[9];           /* ip_dst:16 */
    5959    /* any options */
    6060    if (pIpHdr->ip_hl > 20 / 4)
     
    6363        switch (pIpHdr->ip_hl)
    6464        {
    65             case 6:  iSum += paw[10] + paw[11]; break;
    66             case 7:  iSum += paw[10] + paw[11] + paw[12] + paw[13]; break;
    67             case 8:  iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15]; break;
    68             case 9:  iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17]; break;
    69             case 10: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19]; break;
    70             case 11: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21]; break;
    71             case 12: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23]; break;
    72             case 13: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25]; break;
    73             case 14: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27]; break;
    74             case 15: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27] + paw[28] + paw[29]; break;
     65            case 6:  u32Sum += paw[10] + paw[11]; break;
     66            case 7:  u32Sum += paw[10] + paw[11] + paw[12] + paw[13]; break;
     67            case 8:  u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15]; break;
     68            case 9:  u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17]; break;
     69            case 10: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19]; break;
     70            case 11: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21]; break;
     71            case 12: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23]; break;
     72            case 13: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25]; break;
     73            case 14: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27]; break;
     74            case 15: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27] + paw[28] + paw[29]; break;
    7575            default:
    7676                AssertFailed();
     
    7979
    8080    /* 16-bit one complement fun */
    81     iSum = (iSum >> 16) + (iSum & 0xffff);  /* hi + low words */
    82     iSum += iSum >> 16;                     /* carry */
    83     return (uint16_t)~iSum;
     81    u32Sum = (u32Sum >> 16) + (u32Sum & 0xffff);  /* hi + low words */
     82    u32Sum += u32Sum >> 16;                     /* carry */
     83    return (uint16_t)~u32Sum;
    8484}
    8585
     
    135135{
    136136    uint16_t cbPayload = RT_BE2H_U16(pIpHdr->ip_len) - pIpHdr->ip_hl * 4;
    137     uint32_t iSum = pIpHdr->ip_src.au16[0]
    138                   + pIpHdr->ip_src.au16[1]
    139                   + pIpHdr->ip_dst.au16[0]
    140                   + pIpHdr->ip_dst.au16[1]
     137    uint32_t u32Sum = pIpHdr->ip_src.au16[0]
     138                    + pIpHdr->ip_src.au16[1]
     139                    + pIpHdr->ip_dst.au16[0]
     140                    + pIpHdr->ip_dst.au16[1]
    141141#ifdef RT_BIG_ENDIAN
    142                   + pIpHdr->ip_p
     142                    + pIpHdr->ip_p
    143143#else
    144                   + ((uint32_t)pIpHdr->ip_p << 8)
     144                    + ((uint32_t)pIpHdr->ip_p << 8)
    145145#endif
    146                   + RT_H2BE_U16(cbPayload);
    147     return iSum;
     146                    + RT_H2BE_U16(cbPayload);
     147    return u32Sum;
    148148}
    149149
     
    172172RTDECL(uint32_t) RTNetIPv4PseudoChecksumBits(RTNETADDRIPV4 SrcAddr, RTNETADDRIPV4 DstAddr, uint8_t bProtocol, uint16_t cbPkt)
    173173{
    174     uint32_t iSum = RT_H2BE_U16(SrcAddr.au16[0])
    175                   + RT_H2BE_U16(SrcAddr.au16[1])
    176                   + RT_H2BE_U16(DstAddr.au16[0])
    177                   + RT_H2BE_U16(DstAddr.au16[1])
     174    uint32_t u32Sum = RT_H2BE_U16(SrcAddr.au16[0])
     175                    + RT_H2BE_U16(SrcAddr.au16[1])
     176                    + RT_H2BE_U16(DstAddr.au16[0])
     177                    + RT_H2BE_U16(DstAddr.au16[1])
    178178#ifdef RT_BIG_ENDIAN
    179                   + bProtocol
     179                    + bProtocol
    180180#else
    181                   + ((uint32_t)bProtocol << 8)
     181                    + ((uint32_t)bProtocol << 8)
    182182#endif
    183                   + RT_H2BE_U16(cbPkt);
    184     return iSum;
     183                    + RT_H2BE_U16(cbPkt);
     184    return u32Sum;
    185185}
    186186
     
    191191 * @returns 32-bit intermediary checksum value.
    192192 * @param   pUdpHdr         Pointer to the UDP header to checksum, network endian (big).
    193  * @param   iSum            The 32-bit intermediate checksum value.
    194  */
    195 DECLINLINE(uint32_t) rtNetIPv4AddUDPChecksum(PCRTNETUDP pUdpHdr, uint32_t iSum)
    196 {
    197     iSum += pUdpHdr->uh_sport
    198           + pUdpHdr->uh_dport
    199           /*+ pUdpHdr->uh_sum = 0 */
    200           + pUdpHdr->uh_ulen;
    201     return iSum;
     193 * @param   u32Sum          The 32-bit intermediate checksum value.
     194 */
     195DECLINLINE(uint32_t) rtNetIPv4AddUDPChecksum(PCRTNETUDP pUdpHdr, uint32_t u32Sum)
     196{
     197    u32Sum += pUdpHdr->uh_sport
     198            + pUdpHdr->uh_dport
     199            /*+ pUdpHdr->uh_sum = 0 */
     200            + pUdpHdr->uh_ulen;
     201    return u32Sum;
    202202}
    203203
     
    208208 * @returns 32-bit intermediary checksum value.
    209209 * @param   pUdpHdr         Pointer to the UDP header to checksum, network endian (big).
    210  * @param   iSum            The 32-bit intermediate checksum value.
    211  */
    212 RTDECL(uint32_t) RTNetIPv4AddUDPChecksum(PCRTNETUDP pUdpHdr, uint32_t iSum)
    213 {
    214     return rtNetIPv4AddUDPChecksum(pUdpHdr,iSum);
     210 * @param   u32Sum          The 32-bit intermediate checksum value.
     211 */
     212RTDECL(uint32_t) RTNetIPv4AddUDPChecksum(PCRTNETUDP pUdpHdr, uint32_t u32Sum)
     213{
     214    return rtNetIPv4AddUDPChecksum(pUdpHdr, u32Sum);
    215215}
    216216
     
    223223 *                          Assums the caller has already validate it and made sure the
    224224 *                          entire header is present.
    225  * @param   iSum            The 32-bit intermediate checksum value.
    226  */
    227 DECLINLINE(uint32_t) rtNetIPv4AddTCPChecksum(PCRTNETTCP pTcpHdr, uint32_t iSum)
     225 * @param   u32Sum          The 32-bit intermediate checksum value.
     226 */
     227DECLINLINE(uint32_t) rtNetIPv4AddTCPChecksum(PCRTNETTCP pTcpHdr, uint32_t u32Sum)
    228228{
    229229    uint16_t const *paw = (uint16_t const *)pTcpHdr;
    230     iSum += paw[0]                      /* th_sport */
    231           + paw[1]                      /* th_dport */
    232           + paw[2]                      /* th_seq */
    233           + paw[3]                      /* th_seq:16 */
    234           + paw[4]                      /* th_ack */
    235           + paw[5]                      /* th_ack:16 */
    236           + paw[6]                      /* th_off, th_x2, th_flags */
    237           + paw[7]                      /* th_win */
    238           /*+ paw[8] == 0 */            /* th_sum */
    239           + paw[9];                     /* th_urp */
     230    u32Sum += paw[0]                    /* th_sport */
     231            + paw[1]                    /* th_dport */
     232            + paw[2]                    /* th_seq */
     233            + paw[3]                    /* th_seq:16 */
     234            + paw[4]                    /* th_ack */
     235            + paw[5]                    /* th_ack:16 */
     236            + paw[6]                    /* th_off, th_x2, th_flags */
     237            + paw[7]                    /* th_win */
     238            /*+ paw[8] == 0 */          /* th_sum */
     239            + paw[9];                   /* th_urp */
    240240    if (pTcpHdr->th_off > RTNETTCP_MIN_LEN / 4)
    241241    {
     
    243243        switch (pTcpHdr->th_off)
    244244        {
    245             case 6:  iSum += paw[10] + paw[11]; break;
    246             case 7:  iSum += paw[10] + paw[11] + paw[12] + paw[13]; break;
    247             case 8:  iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15]; break;
    248             case 9:  iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17]; break;
    249             case 10: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19]; break;
    250             case 11: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21]; break;
    251             case 12: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23]; break;
    252             case 13: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25]; break;
    253             case 14: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27]; break;
    254             case 15: iSum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27] + paw[28] + paw[29]; break;
     245            case 6:  u32Sum += paw[10] + paw[11]; break;
     246            case 7:  u32Sum += paw[10] + paw[11] + paw[12] + paw[13]; break;
     247            case 8:  u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15]; break;
     248            case 9:  u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17]; break;
     249            case 10: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19]; break;
     250            case 11: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21]; break;
     251            case 12: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23]; break;
     252            case 13: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25]; break;
     253            case 14: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27]; break;
     254            case 15: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27] + paw[28] + paw[29]; break;
    255255            default:
    256256                AssertFailed();
     
    258258    }
    259259
    260     return iSum;
     260    return u32Sum;
    261261}
    262262
     
    269269 *                          Assums the caller has already validate it and made sure the
    270270 *                          entire header is present.
    271  * @param   iSum            The 32-bit intermediate checksum value.
    272  */
    273 RTDECL(uint32_t) RTNetIPv4AddTCPChecksum(PCRTNETTCP pTcpHdr, uint32_t iSum)
    274 {
    275     return rtNetIPv4AddTCPChecksum(pTcpHdr, iSum);
     271 * @param   u32Sum          The 32-bit intermediate checksum value.
     272 */
     273RTDECL(uint32_t) RTNetIPv4AddTCPChecksum(PCRTNETTCP pTcpHdr, uint32_t u32Sum)
     274{
     275    return rtNetIPv4AddTCPChecksum(pTcpHdr, u32Sum);
    276276}
    277277
     
    282282 * @returns 32-bit intermediary checksum value.
    283283 * @param   pUdpHdr         Pointer to the UDP header to checksum, network endian (big).
    284  * @param   iSum            The 32-bit intermediate checksum value.
     284 * @param   u32Sum          The 32-bit intermediate checksum value.
    285285 * @param   pfOdd           This is used to keep track of odd bits, initialize to false
    286286 *                          when starting to checksum the data (aka text) after a TCP
    287287 *                          or UDP header (data never start at an odd offset).
    288288 */
    289 DECLINLINE(uint32_t) rtNetIPv4AddDataChecksum(void const *pvData, size_t cbData, uint32_t iSum, bool *pfOdd)
     289DECLINLINE(uint32_t) rtNetIPv4AddDataChecksum(void const *pvData, size_t cbData, uint32_t u32Sum, bool *pfOdd)
    290290{
    291291    if (*pfOdd)
     
    293293#ifdef RT_BIG_ENDIAN
    294294        /* there was an odd byte in the previous chunk, add the lower byte. */
    295         iSum += *(uint8_t *)pvData;
     295        u32Sum += *(uint8_t *)pvData;
    296296#else
    297297        /* there was an odd byte in the previous chunk, add the upper byte. */
    298         iSum += (uint32_t)*(uint8_t *)pvData << 8;
     298        u32Sum += (uint32_t)*(uint8_t *)pvData << 8;
    299299#endif
    300300        /* skip the byte. */
    301301        cbData--;
    302302        if (!cbData)
    303             return iSum;
     303            return u32Sum;
    304304        pvData = (uint8_t const *)pvData + 1;
    305305    }
     
    309309    while (cbData > 1)
    310310    {
    311         iSum += *pw;
     311        u32Sum += *pw;
    312312        pw++;
    313313        cbData -= 2;
     
    318318    {
    319319#ifdef RT_BIG_ENDIAN
    320         iSum += (uint32_t)*(uint8_t *)pw << 8;
     320        u32Sum += (uint32_t)*(uint8_t *)pw << 8;
    321321#else
    322         iSum += *(uint8_t *)pw;
     322        u32Sum += *(uint8_t *)pw;
    323323#endif
    324324        *pfOdd = true;
     
    326326    else
    327327        *pfOdd = false;
    328     return iSum;
     328    return u32Sum;
    329329}
    330330
     
    334334 * @returns 32-bit intermediary checksum value.
    335335 * @param   pUdpHdr         Pointer to the UDP header to checksum, network endian (big).
    336  * @param   iSum            The 32-bit intermediate checksum value.
     336 * @param   u32Sum          The 32-bit intermediate checksum value.
    337337 * @param   pfOdd           This is used to keep track of odd bits, initialize to false
    338338 *                          when starting to checksum the data (aka text) after a TCP
    339339 *                          or UDP header (data never start at an odd offset).
    340340 */
    341 RTDECL(uint32_t) RTNetIPv4AddDataChecksum(void const *pvData, size_t cbData, uint32_t iSum, bool *pfOdd)
    342 {
    343     return rtNetIPv4AddDataChecksum(pvData, cbData, iSum, pfOdd);
     341RTDECL(uint32_t) RTNetIPv4AddDataChecksum(void const *pvData, size_t cbData, uint32_t u32Sum, bool *pfOdd)
     342{
     343    return rtNetIPv4AddDataChecksum(pvData, cbData, u32Sum, pfOdd);
    344344}
    345345
     
    349349 *
    350350 * @returns The checksum.
    351  * @param   iSum            The 32-bit intermediate checksum value.
    352  */
    353 DECLINLINE(uint16_t) rtNetIPv4FinalizeChecksum(uint32_t iSum)
     351 * @param   u32Sum          The 32-bit intermediate checksum value.
     352 */
     353DECLINLINE(uint16_t) rtNetIPv4FinalizeChecksum(uint32_t u32Sum)
    354354{
    355355    /* 16-bit one complement fun */
    356     iSum = (iSum >> 16) + (iSum & 0xffff);  /* hi + low words */
    357     iSum += iSum >> 16;                     /* carry */
    358     return (uint16_t)~iSum;
     356    u32Sum = (u32Sum >> 16) + (u32Sum & 0xffff);  /* hi + low words */
     357    u32Sum += u32Sum >> 16;                       /* carry */
     358    return (uint16_t)~u32Sum;
    359359}
    360360
     
    364364 *
    365365 * @returns The checksum.
    366  * @param   iSum            The 32-bit intermediate checksum value.
    367  */
    368 RTDECL(uint16_t) RTNetIPv4FinalizeChecksum(uint32_t iSum)
    369 {
    370     return rtNetIPv4FinalizeChecksum(iSum);
     366 * @param   u32Sum          The 32-bit intermediate checksum value.
     367 */
     368RTDECL(uint16_t) RTNetIPv4FinalizeChecksum(uint32_t u32Sum)
     369{
     370    return rtNetIPv4FinalizeChecksum(u32Sum);
    371371}
    372372
     
    386386RTDECL(uint16_t) RTNetIPv4UDPChecksum(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, void const *pvData)
    387387{
    388     uint32_t iSum = rtNetIPv4PseudoChecksum(pIpHdr);
    389     iSum = rtNetIPv4AddUDPChecksum(pUdpHdr, iSum);
     388    uint32_t u32Sum = rtNetIPv4PseudoChecksum(pIpHdr);
     389    u32Sum = rtNetIPv4AddUDPChecksum(pUdpHdr, u32Sum);
    390390    bool fOdd = false;
    391     iSum = rtNetIPv4AddDataChecksum(pvData, RT_BE2H_U16(pUdpHdr->uh_ulen) - sizeof(*pUdpHdr), iSum, &fOdd);
    392     iSum = rtNetIPv4FinalizeChecksum(iSum);
    393     return iSum;
     391    u32Sum = rtNetIPv4AddDataChecksum(pvData, RT_BE2H_U16(pUdpHdr->uh_ulen) - sizeof(*pUdpHdr), u32Sum, &fOdd);
     392    return rtNetIPv4FinalizeChecksum(u32Sum);
    394393}
    395394
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette