![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to create_crc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / romfs / tools|
Return to create_crc.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / romfs / tools |
1.1 root 1: /******************************************************************************
2: * Copyright (c) 2004, 2008 IBM Corporation
3: * All rights reserved.
4: * This program and the accompanying materials
5: * are made available under the terms of the BSD License
6: * which accompanies this distribution, and is available at
7: * http://www.opensource.org/licenses/bsd-license.php
8: *
9: * Contributors:
10: * IBM Corporation - initial implementation
11: *****************************************************************************/
12:
13: #include <stdint.h>
14: #include <stdio.h>
15: #include <stdlib.h>
16: #include <string.h>
17: #include <sys/types.h>
18: #include <sys/stat.h>
19: #include <netinet/in.h>
20: #include <fcntl.h>
21: #include <string.h>
22: #include <unistd.h>
23: #include <cfgparse.h>
24: #include <time.h>
25: #include <calculatecrc.h>
26: #include <product.h>
27: #include "createcrc.h"
28:
29: int createHeaderImage(int);
30: unsigned int calCRCEthernet32(unsigned char *TextPtr,
31: unsigned long int TextLength,
32: unsigned int AccumCRC);
33: int createCRCParameter(uint64_t * ui64RegisterMask,
34: unsigned int *iRegisterLength);
35: uint64_t calCRCbyte(unsigned char *TextPtr, uint32_t Residual,
36: uint64_t AccumCRC);
37: uint64_t calCRCword(unsigned char *TextPtr, uint32_t Residual,
38: uint64_t AccumCRC);
39: uint64_t checkCRC(unsigned char *TextPtr, uint32_t Residual, uint64_t AccumCRC);
40:
41: /* file length in bytes */
42: static uint64_t ui64globalFileSize = 0;
43: /* space for the file stream >= 4MB + 4bytes */
44: static unsigned char pucFileStream[4400000];
45: /* header length in bytes */
46: static uint64_t ui64globalHeaderSize = 0;
47: /* flag to filter detect the header in buildDataStream() */
48: static int iglobalHeaderFlag = 1;
49: static uint64_t ui64Generator1;
50:
51: /**
52: * Build the file image and store it as Data Stream of bytes
53: * calculate a first CRC for the first file and
54: * catch the position of this CRC
55: */
56: int
57: buildDataStream(unsigned char *pucbuf, int size)
58: {
59: if (ui64globalFileSize + size > sizeof(pucFileStream)) {
60: printf("Error: File size is too big!\n");
61: return -1;
62: }
63:
64: /* copy the data into the destination buffer */
65: memcpy(pucFileStream + ui64globalFileSize, pucbuf, size);
66: ui64globalFileSize += size;
67:
68: if (iglobalHeaderFlag == 1) { // catch header
69:
70: ui64globalHeaderSize = ui64globalFileSize;
71: iglobalHeaderFlag = 0;
72: }
73:
74: return 0;
75: }
76:
77: /**
78: * write Header.img
79: */
80: int
81: createHeaderImage(int notime)
82: {
83: int iCounter;
84: uint64_t ui64RomAddr, ui64DataAddr;
85: time_t caltime;
86: struct tm *tm;
87: char *pcVersion;
88: char dastr[16] = { 0, };
89: unsigned long long da = 0;
90:
91: union {
92: unsigned char pcArray[FLASHFS_HEADER_DATA_SIZE];
93: struct stH stHeader;
94: } uHeader;
95:
96: /* initialize Header */
97: memset(uHeader.pcArray, 0x00, FLASHFS_HEADER_DATA_SIZE);
98:
99: /* read driver info */
100: if (NULL != (pcVersion = getenv("DRIVER_NAME"))) {
101: strncpy(uHeader.stHeader.version, pcVersion, 16);
102: } else if (NULL != (pcVersion = getenv("USER"))) {
103: strncpy(uHeader.stHeader.version, pcVersion, 16);
104: } else if (pcVersion == NULL) {
105: strncpy(uHeader.stHeader.version, "No known user!", 16);
106: }
107:
108: if (!notime) {
109: /* read time and write it into data stream */
110: if ((caltime = time(NULL)) == -1) {
111: printf("time error\n");
112: }
113: if ((tm = localtime(&caltime)) == NULL) {
114: printf("local time error\n");
115: }
116: // length must be 13 instead 12 because of terminating
117: // NUL. Therefore uH.stH.platform_revison must be
118: // writen later to overwrite the terminating NUL
119: if (strftime(dastr, 15, "0x%Y%m%d%H%M", tm) == 0) {
120: printf("strftime error\n");
121: }
122: da = cpu_to_be64(strtoll(dastr, NULL, 16));
123: }
124: memcpy(uHeader.stHeader.date, &da, 8);
125:
126: /* write Magic value into data stream */
127: strncpy(uHeader.stHeader.magic, FLASHFS_MAGIC, 8);
128: /* write platform name into data stream */
129: strcpy(uHeader.stHeader.platform_name, FLASHFS_PLATFORM_MAGIC);
130: /* write platform revision into data stream */
131: strcpy(uHeader.stHeader.platform_revision, FLASHFS_PLATFORM_REVISION);
132:
133:
134: /* fill end of file info (8 bytes of FF) into data stream */
135: uHeader.stHeader.ui64FileEnd = -1;
136:
137: /* read address of next file and address of header date, both are 64 bit values */
138: ui64RomAddr = 0;
139: ui64DataAddr = 0;
140: for (iCounter = 0; iCounter < 8; iCounter++) {
141: /* addr of next file */
142: ui64RomAddr = (ui64RomAddr << 8) + pucFileStream[FLASHFS_ROMADDR + iCounter];
143: /* addr of header data */
144: ui64DataAddr = (ui64DataAddr << 8) + pucFileStream[FLASHFS_DATADDR + iCounter];
145: }
146:
147: /* calculate final flash-header-size and flash-file-size */
148: /* calculate end addr of header */
149: ui64globalHeaderSize = (uint32_t) ui64DataAddr + (uint32_t) FLASHFS_HEADER_DATA_SIZE;
150: /* cut 64 bit to place CRC for File-End */
151: ui64globalHeaderSize -= 8;
152: /* add 64 bit to place CRC behind File-End */
153: ui64globalFileSize += 8;
154:
155: if (ui64globalHeaderSize >= ui64RomAddr) {
156: printf("%s\n", "--- Header File to long");
157: return 1;
158: }
159:
160: /* fill free space in Header with zeros */
161: memset(&pucFileStream[ui64DataAddr], 0, (ui64RomAddr - ui64DataAddr));
162: /* place data to header */
163: memcpy(&pucFileStream[ui64DataAddr], uHeader.pcArray,
164: FLASHFS_HEADER_DATA_SIZE);
165:
166: /* insert header length into data stream */
167: *(uint64_t *) (pucFileStream + FLASHFS_HEADER_SIZE_ADDR) =
168: cpu_to_be64(ui64globalHeaderSize);
169:
170: /* insert flash length into data stream */
171: *(uint64_t *) (pucFileStream + ui64DataAddr + FLASHFS_FILE_SIZE_ADDR) =
172: cpu_to_be64(ui64globalFileSize);
173:
174: /* insert zeros as placeholder for CRC */
175: *(uint64_t *) (pucFileStream + ui64globalHeaderSize - 8) = 0;
176: *(uint64_t *) (pucFileStream + ui64globalFileSize - 8) = 0;
177:
178: return 0;
179: }
180:
181: /**
182: * calculate standart ethernet 32 bit CRC
183: * generator polynome is 0x104C11DB7
184: * this algorithm can be used for encoding and decoding
185: */
186: unsigned int
187: calCRCEthernet32(unsigned char *TextPtr, unsigned long int TextLength,
188: unsigned int AccumCRC)
189: {
190: const unsigned int CrcTableHigh[16] = {
191: 0x00000000, 0x4C11DB70, 0x9823B6E0, 0xD4326D90,
192: 0x34867077, 0x7897AB07, 0xACA5C697, 0xE0B41DE7,
193: 0x690CE0EE, 0x251D3B9E, 0xF12F560E, 0xBD3E8D7E,
194: 0x5D8A9099, 0x119B4BE9, 0xC5A92679, 0x89B8FD09
195: };
196: const unsigned CrcTableLow[16] = {
197: 0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9,
198: 0x130476DC, 0x17C56B6B, 0x1A864DB2, 0x1E475005,
199: 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61,
200: 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD
201: };
202:
203: unsigned char *Buffer = TextPtr;
204: unsigned long int Residual = TextLength;
205:
206:
207: while (Residual > 0) {
208: unsigned int Temp = ((AccumCRC >> 24) ^ *Buffer) & 0x000000ff;
209: AccumCRC <<= 8;
210: AccumCRC ^= CrcTableHigh[Temp / 16];
211: AccumCRC ^= CrcTableLow[Temp % 16];
212: ++Buffer;
213: --Residual;
214: }
215: return AccumCRC;
216: }
217:
218: /**
219: * create CRC Parameter: CRC Polynome, Shiftregister Mask and length
220: *
221: * ui64Generator[0] = 0;
222: * ui64Generator[1] = 0x42F0E1EB;
223: * ui64Generator[1] = (ui64Generator[1] << 32) + 0xA9EA3693;
224: * iRegisterLength = 63;
225: * ui64RegisterMask = 0xffffffff;
226: * ui64RegisterMask = ((ui64RegisterMask) << 32) + 0xffffffff;
227: *
228: * ucl=0x00000000ffffffff = Mask for 32 bit LSFR to cut down number of bits
229: * in the variable to get the same length as LFSR
230: *
231: * il = length of LSFR = degree of generator polynom reduce il by one to calculate the degree
232: * of the highest register in LSFR
233: *
234: * Examples:
235: * CRC-16 for Tap: x16 + x15 + x2 + 1
236: * generator = 0x8005, il = 16, ucl = 0x000000000000FFFF
237: *
238: * CRC-16 for Floppy: x16 + x12 + x5 +1
239: * generator = 0x1021, il = 16, ucl = 0x000000000000FFFF
240: *
241: * CRC-32 for Ethernet: x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x + 1
242: * generator = 0x04C11DB7, il = 32, ucl = 0x00000000FFFFFFFF
243: *
244: * CRC-64 SP-TrEMBL x64 + x4 + x3 + x + 1 (maximal-length LFSR)
245: * generator = 0x1B, il = 64, ucl = 0xFFFFFFFFFFFFFFFF
246: *
247: * CRC-64 improved
248: * x64 + x63 + x61 + x59 + x58 + x56 + x55 + x52 + x49 + x48 + x47 + x46+ x44 +
249: * x41 + x37 + x36 + x34 + x32 + x31 + x28 + x26 + x23 + x22 + x19 + x16 + x13 +
250: * x12 + x10 + x9 + x6 + x4 + x3 + 1
251: * (see http://www.cs.ud.ac.uk/staff/D.Jones/crcbote.pdf)
252: * generator = 0xAD93D23594C9362D, il = 64, ucl = 0xFFFFFFFFFFFFFFFF
253: *
254: * CRC-64 DLT1 spec
255: * x64 + x62 + x57 + x55 + x54 + x53 + x52 + x47 + x46 + x45 + x40 + x39 + x38 + x37 +
256: * x35 + x33 + x32 + x31 + x29 + x27 + x24 + x23 + x22 + x21 + x19 + x17 + x13 + x12 +
257: * x10 + x9 + x7 + x4 + x + 1
258: * (see http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-182.pdf -> page63)
259: * generator = 0x42F0E1EBA9EA3693
260: *
261: * CRC-64 from internet G(x)= 1006003C000F0D50B
262: */
263: int
264: createCRCParameter(uint64_t * ui64RegisterMask, unsigned int *uiRegisterLength)
265: {
266: enum Generators { Tape_16, Floppy_16, Ethernet_32, SPTrEMBL_64,
267: SPTrEMBL_improved_64, DLT1_64
268: };
269: enum Generators Generator;
270:
271: Generator = CRC_METHODE;
272: switch (Generator) {
273: case Tape_16:{
274: *ui64RegisterMask = 0x0000ffff;
275: ui64Generator1 = 0x00008005;
276: *uiRegisterLength = 16;
277: break;
278: }
279: case Floppy_16:{
280: *ui64RegisterMask = 0x0000ffff;
281: ui64Generator1 = 0x00001021;
282: *uiRegisterLength = 16;
283: break;
284: }
285: case Ethernet_32:{
286: *ui64RegisterMask = 0xffffffff;
287: ui64Generator1 = 0x04C11DB7;
288: *uiRegisterLength = 32;
289: break;
290: }
291: case SPTrEMBL_64:{
292: *ui64RegisterMask = 0xffffffff;
293: *ui64RegisterMask =
294: ((*ui64RegisterMask) << 32) + 0xffffffff;
295: ui64Generator1 = 0x0000001B;
296: *uiRegisterLength = 64;
297: break;
298: }
299: case SPTrEMBL_improved_64:{
300: *ui64RegisterMask = 0xffffffff;
301: *ui64RegisterMask =
302: ((*ui64RegisterMask) << 32) + 0xffffffff;
303: ui64Generator1 = 0xAD93D235;
304: ui64Generator1 = (ui64Generator1 << 32) + 0x94C9362D;
305: *uiRegisterLength = 64;
306: break;
307: }
308: case DLT1_64:{
309: *ui64RegisterMask = 0xffffffff;
310: *ui64RegisterMask =
311: ((*ui64RegisterMask) << 32) + 0xffffffff;
312: ui64Generator1 = 0x42F0E1EB;
313: ui64Generator1 = (ui64Generator1 << 32) + 0xA9EA3693;
314: *uiRegisterLength = 64;
315: break;
316: }
317: }
318: (*uiRegisterLength)--;
319:
320: return 0;
321: }
322:
323: /**
324: * Check CRC by using Linear Feadback Shift Register (LFSR)
325: */
326: uint64_t
327: calCRCbyte(unsigned char *cPtr, uint32_t ui32NoWords, uint64_t AccumCRC)
328: {
329:
330: uint64_t ui64Mask, ui64Generator0;
331: uint8_t ui8Buffer;
332: unsigned int uiRegisterLength;
333: int iShift;
334:
335: createCRCParameter(&ui64Mask, &uiRegisterLength);
336:
337: ui8Buffer = (*cPtr);
338: while (ui32NoWords > 0) {
339: for (iShift = 7; iShift >= 0; iShift--) {
340:
341: ui64Generator0 = (AccumCRC >> uiRegisterLength);
342: AccumCRC <<= 1;
343: ui64Generator0 &= 0x01;
344: ui64Generator0 = (0 - ui64Generator0);
345: AccumCRC ^= (ui64Generator1 & ui64Generator0);
346: }
347: AccumCRC ^= ui8Buffer;
348: AccumCRC &= ui64Mask;
349: ui32NoWords -= 1;
350: cPtr += 1;
351: ui8Buffer = (*cPtr);
352: }
353: return AccumCRC;
354: }
355:
356: /**
357: * Check CRC by using Linear Feadback Shift Register (LFSR)
358: */
359: uint64_t
360: calCRCword(unsigned char *cPtr, uint32_t ui32NoWords, uint64_t AccumCRC)
361: {
362:
363: uint64_t ui64Mask, ui64Generator0;
364: uint16_t ui16Buffer;
365: unsigned int uiRegisterLength;
366: int iShift;
367:
368: createCRCParameter(&ui64Mask, &uiRegisterLength);
369:
370: if ((ui32NoWords % 2) != 0) {
371: /* if Data string does not end at word boundery add one byte */
372: ui32NoWords++;
373: cPtr[ui32NoWords] = 0;
374: }
375: ui16Buffer = ((*(cPtr + 0)) * 256) + (*(cPtr + 1));
376: while (ui32NoWords > 0) {
377: for (iShift = 15; iShift >= 0; iShift--) {
378: ui64Generator0 = (AccumCRC >> uiRegisterLength);
379: AccumCRC <<= 1;
380: ui64Generator0 &= 0x01;
381: ui64Generator0 = (0 - ui64Generator0);
382: AccumCRC ^= (ui64Generator1 & ui64Generator0);
383: }
384: AccumCRC ^= ui16Buffer;
385: AccumCRC &= ui64Mask;
386: ui32NoWords -= 2;
387: cPtr += 2;
388: ui16Buffer = ((*(cPtr + 0)) * 256) + (*(cPtr + 1));
389: }
390: return AccumCRC;
391: }
392:
393: uint64_t
394: checkCRC(unsigned char *cPtr, uint32_t ui32NoWords, uint64_t AccumCRC)
395: {
396:
397: enum Generators { Ethernet_32 };
398: enum Generators Generator;
399: uint64_t ui64Buffer = AccumCRC;
400:
401: Generator = CRC_METHODE;
402:
403: switch (Generator) {
404: case Ethernet_32:{
405: /* (ui32NoWords - 4),no need of 4 bytes 0x as
406: * with shift-register method */
407: AccumCRC =
408: calCRCEthernet32(cPtr, (ui32NoWords - 4), AccumCRC);
409: break;
410: }
411: default:{
412: AccumCRC = calCRCword(cPtr, ui32NoWords, AccumCRC);
413: break;
414: }
415: }
416:
417: if (calCRCbyte(cPtr, ui32NoWords, ui64Buffer) != AccumCRC) {
418: printf("\n --- big Endian - small Endian problem --- \n");
419: AccumCRC--;
420: }
421:
422: return (AccumCRC);
423: }
424:
425: /**
426: * insert header and file CRC into data stream
427: * do CRC check on header and file
428: * write data stream to disk
429: */
430: int
431: writeDataStream(int iofd, int notime)
432: {
433: uint64_t ui64FileCRC = 0, ui64HeaderCRC = 0, ui64RegisterMask;
434: unsigned int uiRegisterLength;
435:
436: if (0 != createHeaderImage(notime)) {
437: return 1;
438: }
439:
440: createCRCParameter(&ui64RegisterMask, &uiRegisterLength);
441:
442: /* calculate CRC */
443: ui64HeaderCRC = checkCRC(pucFileStream, ui64globalHeaderSize, 0);
444: *(uint64_t *) (pucFileStream + ui64globalHeaderSize - 8) =
445: cpu_to_be64(ui64HeaderCRC);
446:
447: ui64FileCRC = checkCRC(pucFileStream, ui64globalFileSize, 0);
448: *(uint64_t *) (pucFileStream + ui64globalFileSize - 8) =
449: cpu_to_be64(ui64FileCRC);
450:
451: /* check CRC-implementation */
452: ui64HeaderCRC = calCRCword(pucFileStream, ui64globalHeaderSize, 0);
453: ui64FileCRC = calCRCword(pucFileStream, ui64globalFileSize, 0);
454:
455: if ((ui64HeaderCRC != 0) || (ui64FileCRC != 0)) {
456: printf("\n\n %s \n %s \n\n", "CRCs not correct implemented.",
457: " ---> Data will not be written do disk.");
458: return -1;
459: }
460:
461: /* write file image to disk */
462: if (0 < write(iofd, pucFileStream, ui64globalFileSize))
463: return 0;
464:
465: printf("<< write failed >>\n");
466: return -1;
467: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.