diff options
Diffstat (limited to 'src/util/crypto_crc.c')
-rw-r--r-- | src/util/crypto_crc.c | 201 |
1 files changed, 0 insertions, 201 deletions
diff --git a/src/util/crypto_crc.c b/src/util/crypto_crc.c deleted file mode 100644 index 804d3eba8..000000000 --- a/src/util/crypto_crc.c +++ /dev/null | |||
@@ -1,201 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | Copyright (C) 2001, 2002, 2003, 2004, 2006 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | |||
20 | For the actual CRC-32 code: | ||
21 | Copyright abandoned; this code is in the public domain. | ||
22 | Provided to GNUnet by peter@horizon.com | ||
23 | */ | ||
24 | |||
25 | /** | ||
26 | * @file util/crypto_crc.c | ||
27 | * @brief implementation of CRC16 and CRC32 | ||
28 | * @author Christian Grothoff | ||
29 | */ | ||
30 | #include "platform.h" | ||
31 | #include "gnunet_crypto_lib.h" | ||
32 | |||
33 | #define LOG(kind, ...) GNUNET_log_from (kind, "util-crypto-crc", __VA_ARGS__) | ||
34 | |||
35 | /* Avoid wasting space on 8-byte longs. */ | ||
36 | #if UINT_MAX >= 0xffffffff | ||
37 | typedef unsigned int GNUNET_uLong; | ||
38 | #elif ULONG_MAX >= 0xffffffff | ||
39 | typedef unsigned long GNUNET_uLong; | ||
40 | #else | ||
41 | #error This compiler is not ANSI-compliant! | ||
42 | #endif | ||
43 | |||
44 | #define Z_NULL 0 | ||
45 | |||
46 | |||
47 | #define POLYNOMIAL (GNUNET_uLong) 0xedb88320 | ||
48 | static GNUNET_uLong crc_table[256]; | ||
49 | |||
50 | /* | ||
51 | * This routine writes each crc_table entry exactly once, | ||
52 | * with the correct final value. Thus, it is safe to call | ||
53 | * even on a table that someone else is using concurrently. | ||
54 | */ | ||
55 | static void | ||
56 | crc_init () | ||
57 | { | ||
58 | static int once; | ||
59 | unsigned int i, j; | ||
60 | GNUNET_uLong h = 1; | ||
61 | |||
62 | if (once) | ||
63 | return; | ||
64 | once = 1; | ||
65 | crc_table[0] = 0; | ||
66 | for (i = 128; i; i >>= 1) | ||
67 | { | ||
68 | h = (h >> 1) ^ ((h & 1) ? POLYNOMIAL : 0); | ||
69 | /* h is now crc_table[i] */ | ||
70 | for (j = 0; j < 256; j += 2 * i) | ||
71 | crc_table[i + j] = crc_table[j] ^ h; | ||
72 | } | ||
73 | } | ||
74 | |||
75 | |||
76 | /* | ||
77 | * This computes the standard preset and inverted CRC, as used | ||
78 | * by most networking standards. Start by passing in an initial | ||
79 | * chaining value of 0, and then pass in the return value from the | ||
80 | * previous crc32() call. The final return value is the CRC. | ||
81 | * Note that this is a little-endian CRC, which is best used with | ||
82 | * data transmitted lsbit-first, and it should, itself, be appended | ||
83 | * to data in little-endian byte and bit order to preserve the | ||
84 | * property of detecting all burst errors of length 32 bits or less. | ||
85 | */ | ||
86 | static GNUNET_uLong | ||
87 | crc32 (GNUNET_uLong crc, const char *buf, size_t len) | ||
88 | { | ||
89 | crc_init (); | ||
90 | GNUNET_assert (crc_table[255] != 0); | ||
91 | crc ^= 0xffffffff; | ||
92 | while (len--) | ||
93 | crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; | ||
94 | return crc ^ 0xffffffff; | ||
95 | } | ||
96 | |||
97 | |||
98 | /** | ||
99 | * Compute the CRC32 checksum for the first len bytes of the buffer. | ||
100 | * | ||
101 | * @param buf the data over which we're taking the CRC | ||
102 | * @param len the length of the buffer | ||
103 | * @return the resulting CRC32 checksum | ||
104 | */ | ||
105 | int32_t | ||
106 | GNUNET_CRYPTO_crc32_n (const void *buf, size_t len) | ||
107 | { | ||
108 | GNUNET_uLong crc; | ||
109 | |||
110 | crc = crc32 (0L, Z_NULL, 0); | ||
111 | crc = crc32 (crc, (char *) buf, len); | ||
112 | return crc; | ||
113 | } | ||
114 | |||
115 | |||
116 | /** | ||
117 | * Perform an incremental step in a CRC16 (for TCP/IP) calculation. | ||
118 | * | ||
119 | * @param sum current sum, initially 0 | ||
120 | * @param buf buffer to calculate CRC over (must be 16-bit aligned) | ||
121 | * @param len number of bytes in hdr, must be multiple of 2 | ||
122 | * @return updated crc sum (must be subjected to #GNUNET_CRYPTO_crc16_finish() to get actual crc16) | ||
123 | */ | ||
124 | uint32_t | ||
125 | GNUNET_CRYPTO_crc16_step (uint32_t sum, const void *buf, size_t len) | ||
126 | { | ||
127 | const uint16_t *hdr = buf; | ||
128 | |||
129 | for (; len >= 2; len -= 2) | ||
130 | sum += *(hdr++); | ||
131 | if (len == 1) | ||
132 | sum += (*hdr) & ntohs (0xFF00); | ||
133 | return sum; | ||
134 | } | ||
135 | |||
136 | |||
137 | /** | ||
138 | * Convert results from #GNUNET_CRYPTO_crc16_step() to final crc16. | ||
139 | * | ||
140 | * @param sum cumulative sum | ||
141 | * @return crc16 value | ||
142 | */ | ||
143 | uint16_t | ||
144 | GNUNET_CRYPTO_crc16_finish (uint32_t sum) | ||
145 | { | ||
146 | sum = (sum >> 16) + (sum & 0xFFFF); | ||
147 | sum += (sum >> 16); | ||
148 | |||
149 | return ~sum; | ||
150 | } | ||
151 | |||
152 | |||
153 | /** | ||
154 | * Calculate the checksum of a buffer in one step. | ||
155 | * | ||
156 | * @param buf buffer to calculate CRC over (must be 16-bit aligned) | ||
157 | * @param len number of bytes in hdr, must be multiple of 2 | ||
158 | * @return crc16 value | ||
159 | */ | ||
160 | uint16_t | ||
161 | GNUNET_CRYPTO_crc16_n (const void *buf, size_t len) | ||
162 | { | ||
163 | const uint16_t *hdr = buf; | ||
164 | uint32_t sum = GNUNET_CRYPTO_crc16_step (0, hdr, len); | ||
165 | |||
166 | return GNUNET_CRYPTO_crc16_finish (sum); | ||
167 | } | ||
168 | |||
169 | |||
170 | /** | ||
171 | * @ingroup hash | ||
172 | * Calculate the checksum of a buffer in one step. | ||
173 | * | ||
174 | * @param buf buffer to calculate CRC over | ||
175 | * @param len number of bytes in @a buf | ||
176 | * @return crc8 value | ||
177 | */ | ||
178 | uint8_t | ||
179 | GNUNET_CRYPTO_crc8_n (const void *buf, | ||
180 | size_t len) | ||
181 | { | ||
182 | const uint8_t *data = buf; | ||
183 | unsigned int crc = 0; | ||
184 | int i; | ||
185 | int j; | ||
186 | |||
187 | for (j = len; 0 != j; j--) | ||
188 | { | ||
189 | crc ^= (*data++ << 8); | ||
190 | for (i = 8; 0 != i; i--) | ||
191 | { | ||
192 | if (0 != (crc & 0x8000)) | ||
193 | crc ^= (0x1070 << 3); | ||
194 | crc <<= 1; | ||
195 | } | ||
196 | } | ||
197 | return (uint8_t) (crc >> 8); | ||
198 | } | ||
199 | |||
200 | |||
201 | /* end of crypto_crc.c */ | ||