Changeset 89c57b6 in mainline for uspace/lib/net/generic/net_checksum.c

Timestamp:

2011-04-13T14:45:41Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

88634420

Parents:

cefb126 (diff), 17279ead (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

File:

• uspace/lib/net/generic/net_checksum.c (modified) (4 diffs)

uspace/lib/net/generic/net_checksum.c

@@ -27 +27 @@
  */
 
-/** @addtogroup net
- *  @{
+/** @addtogroup libnet
+ * @{
  */
 
 /** @file
- *  General CRC and checksum computation implementation.
+ * General CRC and checksum computation implementation.
  */
 
@@ -39 +39 @@
 #include <net_checksum.h>
 
-/** Big-endian encoding CRC divider.
- */
-#define CRC_DIVIDER_BE  0x04C11DB7
-
-/** Little-endian encoding CRC divider.
- */
-#define CRC_DIVIDER_LE  0xEDB88320
-
-uint16_t compact_checksum(uint32_t sum){
-        // shorten to the 16 bits
-        while(sum >> 16){
-                sum = (sum &0xFFFF) + (sum >> 16);
-        }
+/** Big-endian encoding CRC divider. */
+#define CRC_DIVIDER_BE  0x04c11db7
+
+/** Little-endian encoding CRC divider. */
+#define CRC_DIVIDER_LE  0xedb88320
+
+/** Compacts the computed checksum to the 16 bit number adding the carries.
+ *
+ * @param[in] sum       Computed checksum.
+ * @return              Compacted computed checksum to the 16 bits.
+ */
+uint16_t compact_checksum(uint32_t sum)
+{
+        /* Shorten to the 16 bits */
+        while (sum >> 16)
+                sum = (sum & 0xffff) + (sum >> 16);
 
         return (uint16_t) sum;
 }
 
-uint32_t compute_checksum(uint32_t seed, uint8_t * data, size_t length){
+/** Computes sum of the 2 byte fields.
+ *
+ * Padds one zero (0) byte if odd.
+ *
+ * @param[in] seed      Initial value. Often used as 0 or ~0.
+ * @param[in] data      Pointer to the beginning of data to process.
+ * @param[in] length    Length of the data in bytes.
+ * @return              The computed checksum of the length bytes of the data.
+ */
+uint32_t compute_checksum(uint32_t seed, uint8_t *data, size_t length)
+{
         size_t index;
 
-        // sum all the 16 bit fields
-        for(index = 0; index + 1 < length; index += 2){
+        /* Sum all the 16 bit fields */
+        for (index = 0; index + 1 < length; index += 2)
                 seed += (data[index] << 8) + data[index + 1];
-        }
-
-        // last odd byte with zero padding
-        if(index + 1 == length){
+
+        /* Last odd byte with zero padding */
+        if (index + 1 == length)
                 seed += data[index] << 8;
-        }
 
         return seed;
 }
 
-uint32_t compute_crc32_be(uint32_t seed, uint8_t * data, size_t length){
+/** Computes CRC32 value in the big-endian environment.
+ *
+ * @param[in] seed      Initial value. Often used as 0 or ~0.
+ * @param[in] data      Pointer to the beginning of data to process.
+ * @param[in] length    Length of the data in bits.
+ * @return              The computed CRC32 of the length bits of the data.
+ */
+uint32_t compute_crc32_be(uint32_t seed, uint8_t * data, size_t length)
+{
         size_t index;
 
-        // process full bytes
-        while(length >= 8){
-                // add the data
+        /* Process full bytes */
+        while (length >= 8) {
+                /* Add the data */
                 seed ^= (*data) << 24;
-                // for each added bit
-                for(index = 0; index < 8; ++ index){
-                        // if the first bit is set
-                        if(seed &0x80000000){
-                                // shift and divide the checksum
+                
+                /* For each added bit */
+                for (index = 0; index < 8; ++index) {
+                        /* If the first bit is set */
+                        if (seed & 0x80000000) {
+                                /* Shift and divide the checksum */
                                 seed = (seed << 1) ^ ((uint32_t) CRC_DIVIDER_BE);
-                        }else{
-                                // shift otherwise
+                        } else {
+                                /* Shift otherwise */
                                 seed <<= 1;
                         }
                 }
-                // move to the next byte
-                ++ data;
+                
+                /* Move to the next byte */
+                ++data;
                 length -= 8;
         }
 
-        // process the odd bits
-        if(length > 0){
-                // add the data with zero padding
-                seed ^= ((*data) &(0xFF << (8 - length))) << 24;
-                // for each added bit
-                for(index = 0; index < length; ++ index){
-                        // if the first bit is set
-                        if(seed &0x80000000){
-                                // shift and divide the checksum
+        /* Process the odd bits */
+        if (length > 0) {
+                /* Add the data with zero padding */
+                seed ^= ((*data) & (0xff << (8 - length))) << 24;
+                
+                /* For each added bit */
+                for (index = 0; index < length; ++index) {
+                        /* If the first bit is set */
+                        if (seed & 0x80000000) {
+                                /* Shift and divide the checksum */
                                 seed = (seed << 1) ^ ((uint32_t) CRC_DIVIDER_BE);
-                        }else{
-                                // shift otherwise
+                        } else {
+                                /* Shift otherwise */
                                 seed <<= 1;
                         }
@@ -115 +137 @@
 }
 
-uint32_t compute_crc32_le(uint32_t seed, uint8_t * data, size_t length){
+/** Computes CRC32 value in the little-endian environment.
+ *
+ * @param[in] seed      Initial value. Often used as 0 or ~0.
+ * @param[in] data      Pointer to the beginning of data to process.
+ * @param[in] length    Length of the data in bits.
+ * @return              The computed CRC32 of the length bits of the data.
+ */
+uint32_t compute_crc32_le(uint32_t seed, uint8_t * data, size_t length)
+{
         size_t index;
 
-        // process full bytes
-        while(length >= 8){
-                // add the data
+        /* Process full bytes */
+        while (length >= 8) {
+                /* Add the data */
                 seed ^= (*data);
-                // for each added bit
-                for(index = 0; index < 8; ++ index){
-                        // if the last bit is set
-                        if(seed &1){
-                                // shift and divide the checksum
+                
+                /* For each added bit */
+                for (index = 0; index < 8; ++index) {
+                        /* If the last bit is set */
+                        if (seed & 1) {
+                                /* Shift and divide the checksum */
                                 seed = (seed >> 1) ^ ((uint32_t) CRC_DIVIDER_LE);
-                        }else{
-                                // shift otherwise
+                        } else {
+                                /* Shift otherwise */
                                 seed >>= 1;
                         }
                 }
-                // move to the next byte
-                ++ data;
+                
+                /* Move to the next byte */
+                ++data;
                 length -= 8;
         }
 
-        // process the odd bits
-        if(length > 0){
-                // add the data with zero padding
+        /* Process the odd bits */
+        if (length > 0) {
+                /* Add the data with zero padding */
                 seed ^= (*data) >> (8 - length);
-                for(index = 0; index < length; ++ index){
-                        // if the last bit is set
-                        if(seed &1){
-                                // shift and divide the checksum
+                
+                for (index = 0; index < length; ++index) {
+                        /* If the last bit is set */
+                        if (seed & 1) {
+                                /* Shift and divide the checksum */
                                 seed = (seed >> 1) ^ ((uint32_t) CRC_DIVIDER_LE);
-                        }else{
-                                // shift otherwise
+                        } else {
+                                /* Shift otherwise */
                                 seed >>= 1;
                         }
@@ -157 +190 @@
 }
 
-uint16_t flip_checksum(uint16_t checksum){
-        // flip, zero is returned as 0xFFFF (not flipped)
-        checksum = ~ checksum;
+/** Returns or flips the checksum if zero.
+ *
+ * @param[in] checksum  The computed checksum.
+ * @return              The internet protocol header checksum.
+ * @return              0xFFFF if the computed checksum is zero.
+ */
+uint16_t flip_checksum(uint16_t checksum)
+{
+        /* Flip, zero is returned as 0xFFFF (not flipped) */
+        checksum = ~checksum;
         return checksum ? checksum : IP_CHECKSUM_ZERO;
 }
 
-uint16_t ip_checksum(uint8_t * data, size_t length){
-        // compute, compact and flip the data checksum
-        return flip_checksum(compact_checksum(compute_checksum(0, data, length)));
+/** Computes the ip header checksum.
+ *
+ * To compute the checksum of a new packet, the checksum header field must be
+ * zero. To check the checksum of a received packet, the checksum may be left
+ * set. Zero will be returned in this case if valid.
+ *
+ * @param[in] data      The header data.
+ * @param[in] length    The header length in bytes.
+ * @return              The internet protocol header checksum.
+ * @return              0xFFFF if the computed checksum is zero.
+ */
+uint16_t ip_checksum(uint8_t *data, size_t length)
+{
+        /* Compute, compact and flip the data checksum */
+        return flip_checksum(compact_checksum(compute_checksum(0, data,
+            length)));
 }