Annotation of libaitcrc/src/aitcrc.c, revision 1.5.2.1
1.1 misho 1: /*************************************************************************
2: * (C) 2008 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
3: * by Michael Pounov <misho@openbsd-bg.org>
4: *
5: * $Author: misho $
1.5.2.1 ! misho 6: * $Id: aitcrc.c,v 1.5 2012/07/04 14:53:43 misho Exp $
1.1 misho 7: *
1.4 misho 8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
1.5 misho 15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
1.4 misho 16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
1.1 misho 46: #include "global.h"
47:
48:
49: static int crc_Errno;
1.5.2.1 ! misho 50: static char crc_Error[STRSIZ];
1.1 misho 51:
1.5 misho 52: /* Adler module */
1.3 misho 53: const u_int crc_modAdler = 0xFFF1L;
1.1 misho 54:
1.5 misho 55: /* All known library CRC types ... */
1.1 misho 56: const crcPoly_t crc_Poly[] = {
1.3 misho 57: { 1, (u_int) 0x1, "CRC-1-Parity" },
58: { 4, (u_int) 0x3, "CRC-4-ITU" },
59: { 5, (u_int) 0x15, "CRC-5-ITU" },
60: { 6, (u_int) 0x3, "CRC-6-ITU" },
61: { 7, (u_int) 0x9, "CRC-7-MMC" },
62: { 8, (u_int) 0x8D, "CRC-8-CCITT" },
63: { 10, (u_int) 0x233, "CRC-10" },
64: { 11, (u_int) 0x385, "CRC-11-FlexRay" },
65: { 12, (u_int) 0x80F, "CRC-12-Telco" },
66: { 15, (u_int) 0x4599, "CRC-15-CAN" },
67: { 16, (u_int) 0x8005, "CRC-16-IBM" },
68: { 24, (u_int) 0x864CFB, "CRC-24-Radix64" },
69: { 30, (u_int) 0x2030B9C7, "CRC-30-CDMA" },
70: { 32, (u_int) 0x04C11DB7, "CRC-32-802.3" }
1.1 misho 71: };
72:
73:
1.5 misho 74: /*
75: * Error maintenance functions ...
76: */
1.2 misho 77:
1.5 misho 78: /* crc_GetErrno() Get error code of last operation */
79: inline int
80: crc_GetErrno()
1.1 misho 81: {
82: return crc_Errno;
83: }
84:
1.5 misho 85: /* crc_GetError() Get error text of last operation */
86: inline const char *
87: crc_GetError()
1.1 misho 88: {
89: return crc_Error;
90: }
91:
1.5 misho 92: /* crc_SetErr() Set error to variables for internal use!!! */
93: inline void
94: crc_SetErr(int eno, char *estr, ...)
1.2 misho 95: {
96: va_list lst;
97:
98: crc_Errno = eno;
1.5 misho 99: memset(crc_Error, 0, sizeof crc_Error);
1.2 misho 100: va_start(lst, estr);
1.5 misho 101: vsnprintf(crc_Error, sizeof crc_Error, estr, lst);
1.2 misho 102: va_end(lst);
103: }
104:
1.1 misho 105:
1.2 misho 106: /*
1.5 misho 107: * crcReflect() - Reflect all bits of number
108: *
1.2 misho 109: * @crcNum = Number for reflection
110: * @crcBits = Number width bits
111: * return: -1 error, !=-1 reflecting number
112: */
1.3 misho 113: inline u_int
114: crcReflect(u_int crcNum, u_char crcBits)
1.1 misho 115: {
1.3 misho 116: register u_int i, j, rev;
1.1 misho 117:
1.3 misho 118: for (i = (u_int) 1 << (crcBits - 1), j = 1, rev ^= rev; i; i >>= 1, j <<= 1)
1.1 misho 119: if (crcNum & i)
120: rev |= j;
121:
122: crc_Errno ^= crc_Errno;
123: return rev;
124: }
125:
1.2 misho 126: /*
1.5 misho 127: * crcCalc() - Generic CRC calculation function for many sub variants of CRC algorithms
128: *
1.2 misho 129: * @psBuf = Data for calculation
130: * @bufLen = Length of data
131: * @crcBits = CRC algorithm bits (1, 4, 5, 6, 7, 8, 10, 11, 12, 15, 16, 24, 30, 32)
132: * @RevOpts = Options for computation (REVOPTS_REVERTBYTE, REVOPTS_REVERTCRC)
133: * @initCRC = Initial CRC value
134: * @xorCRC = Last xor CRC value
135: * return: -1 error, !=-1 CRC checksum
136: */
1.3 misho 137: inline u_int
138: crcCalc(u_char * __restrict psBuf, u_int bufLen, u_char crcBits, u_char RevOpts, u_int initCRC, u_int xorCRC)
1.1 misho 139: {
1.3 misho 140: const u_int bits = sizeof(int) * 8 - crcBits;
141: u_int poly, crchibit, crc;
142: register u_int i, j, b, ch;
1.1 misho 143:
1.5 misho 144: assert(psBuf);
1.1 misho 145:
146: switch (crcBits) {
147: case 1:
148: poly = crc_Poly[0].poly_num;
149: break;
150: case 4:
151: poly = crc_Poly[1].poly_num;
152: break;
153: case 5:
154: poly = crc_Poly[2].poly_num;
155: break;
156: case 6:
157: poly = crc_Poly[3].poly_num;
158: break;
159: case 7:
160: poly = crc_Poly[4].poly_num;
161: break;
162: case 8:
163: poly = crc_Poly[5].poly_num;
164: break;
165: case 10:
166: poly = crc_Poly[6].poly_num;
167: break;
168: case 11:
169: poly = crc_Poly[7].poly_num;
170: break;
171: case 12:
172: poly = crc_Poly[8].poly_num;
173: break;
174: case 15:
175: poly = crc_Poly[9].poly_num;
176: break;
177: case 16:
178: poly = crc_Poly[10].poly_num;
179: break;
180: case 24:
181: poly = crc_Poly[11].poly_num;
182: break;
183: case 30:
184: poly = crc_Poly[12].poly_num;
185: break;
186: case 32:
187: poly = crc_Poly[13].poly_num;
188: break;
189: default:
1.5 misho 190: crc_SetErr(EINVAL, "crcCalc(): Unsupported CRC method!!!");
1.1 misho 191: return -1;
192: }
193: poly <<= bits;
194:
1.3 misho 195: crchibit = (u_int) 1 << (crcBits - 1);
1.1 misho 196: crchibit <<= bits;
197: crc = initCRC << bits;
198:
199: for (i = 0; i < bufLen; i++) {
1.3 misho 200: ch = (u_int) *psBuf++;
1.1 misho 201: if (RevOpts & REVOPTS_REVERTBYTE)
202: ch = crcReflect(ch, 8);
203:
204: for (j = 0x80; j; j >>= 1) {
205: b = crc & crchibit;
206: crc <<= 1;
207:
208: if (ch & j)
209: b ^= crchibit;
210: if (b)
211: crc ^= poly;
212: }
213: }
214:
215: if (RevOpts & REVOPTS_REVERTCRC)
1.3 misho 216: crc = crcReflect(crc, sizeof(int) * 8);
1.1 misho 217: crc ^= xorCRC << bits;
218: crc &= (((crchibit - 1) << 1) | 1);
219: if (!(RevOpts & REVOPTS_REVERTCRC))
220: crc >>= bits;
221:
222: crc_Errno ^= crc_Errno;
223: return crc;
224: }
225:
226:
1.2 misho 227: /*
1.5 misho 228: * crcIP() - Checksum in IP communication
229: *
230: * @buf = Data for calculation
1.2 misho 231: * @bufLen = Length of data
232: * return: -1 error, !=-1 Checksum
233: */
1.3 misho 234: inline u_short
1.5 misho 235: crcIP(u_char * __restrict buf, int bufLen)
1.1 misho 236: {
1.3 misho 237: register u_int sum;
1.5 misho 238: u_short last = 0, *nBuf = (u_short*) buf;
1.1 misho 239:
1.5 misho 240: assert(buf);
1.1 misho 241:
1.5 misho 242: for (sum = 0; bufLen && bufLen > 1; bufLen -= 2)
1.1 misho 243: sum += *nBuf++;
1.5 misho 244: if (bufLen == 1) {
245: *(u_char*)(&last) += *(u_char*) nBuf;
246: sum += last;
247: }
1.1 misho 248:
249: sum = (sum >> 16) + (sum & 0xFFFF);
250: sum += sum >> 16;
251:
252: crc_Errno ^= crc_Errno;
253: return (u_short) ~sum;
254: }
255:
1.2 misho 256: /*
1.5 misho 257: * crcFletcher16() - Fletcher-16 Checksum computing
258: *
1.2 misho 259: * @nBuf = Data for calculation
260: * @bufLen = Length of data
261: * return: -1 error, !=-1 Checksum
262: */
1.3 misho 263: inline u_short
264: crcFletcher16(u_short * __restrict nBuf, int bufLen)
1.1 misho 265: {
1.3 misho 266: register u_short s1, s2;
267: register u_int clen;
268:
1.5 misho 269: assert(nBuf);
1.3 misho 270:
271: s1 = s2 = 0xFF;
272: while (bufLen) {
273: clen = bufLen > MAX_FLETCHER16_DIGEST ? MAX_FLETCHER16_DIGEST : bufLen;
274: bufLen -= clen;
275:
276: do {
277: s1 += (u_short) *nBuf++;
278: s2 += s1;
279: } while (--clen);
280:
281: s1 = (s1 >> 8) + (s1 & 0xFF);
282: s2 = (s2 >> 8) + (s2 & 0xFF);
283: }
284:
285: crc_Errno ^= crc_Errno;
286: return (s2 << 8) | s1;
287: }
288:
289: /*
1.5 misho 290: * crcFletcher() - Fletcher-32 Checksum computing
291: *
1.3 misho 292: * @nBuf = Data for calculation
293: * @bufLen = Length of data
294: * return: -1 error, !=-1 Checksum
295: */
296: inline u_int
297: crcFletcher(u_short * __restrict nBuf, int bufLen)
298: {
299: register u_int s1, s2, clen;
1.1 misho 300:
1.5 misho 301: assert(nBuf);
1.1 misho 302:
303: s1 = s2 = 0xFFFF;
304: while (bufLen) {
305: clen = bufLen > MAX_FLETCHER_DIGEST ? MAX_FLETCHER_DIGEST : bufLen;
306: bufLen -= clen;
307:
308: do {
1.3 misho 309: s1 += (u_int) *nBuf++;
1.1 misho 310: s2 += s1;
311: } while (--clen);
312:
313: s1 = (s1 >> 16) + (s1 & 0xFFFF);
314: s2 = (s2 >> 16) + (s2 & 0xFFFF);
315: }
316:
317: crc_Errno ^= crc_Errno;
318: return (s2 << 16) | s1;
319: }
320:
1.2 misho 321: /*
1.5 misho 322: * crcAdler() - crcAdler-32 Checksum computing
323: *
1.2 misho 324: * @psBuf = Data for calculation
325: * @bufLen = Length of data
326: * return: -1 error, !=-1 Checksum
327: */
1.3 misho 328: inline u_int
329: crcAdler(u_char * __restrict psBuf, int bufLen)
1.1 misho 330: {
1.3 misho 331: register u_int s1, s2, clen;
1.1 misho 332:
1.5 misho 333: assert(psBuf);
1.1 misho 334:
335: s1 = 1L;
336: s2 ^= s2;
337: while (bufLen) {
338: clen = bufLen > MAX_ADLER_DIGEST ? MAX_ADLER_DIGEST : bufLen;
339: bufLen -= clen;
340:
341: do {
1.3 misho 342: s1 += (u_int) *psBuf++;
1.1 misho 343: s2 += s1;
344: } while (--clen);
345:
346: s1 %= crc_modAdler;
347: s2 %= crc_modAdler;
348: }
349:
350: crc_Errno ^= crc_Errno;
351: return (s2 << 16) | s1;
352: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to aitcrc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitcrc / src