Boolean_T crc32file(char *name, DWORD *crc, long *charcnt)
{
register FILE *fin;
register DWORD oldcrc32;
register int c;
oldcrc32 = 0xFFFFFFFF; *charcnt = 0;
#ifdef MSDOS
if ((fin=fopen(name, "rb"))==NULL)
#else
if ((fin=fopen(name, "r"))==NULL)
#endif
{
perror(name);
return Error_;
}
while ((c=getc(fin))!=EOF)
{
++*charcnt;
oldcrc32 = UPDC32(c, oldcrc32);
}
if (ferror(fin))
{
perror(name);
*charcnt = -1;
}
fclose(fin);
*crc = oldcrc32 = ~oldcrc32;
return Success_;
}
/* Capture the keyboard, as long as the event is not the same as the last two
events, add the crc of the event to the pool along with the crc of the time
difference between this event and the last. The role of CRC-32 is merely to
perform diffusion. Note that the output of CRC-32 is subsequently processed
using a cryptographically secure hash algorithm. */
LRESULT CALLBACK KeyboardProc (int nCode, WPARAM wParam, LPARAM lParam)
{
static int lLastKey, lLastKey2;
static DWORD dwLastTimer;
int nKey = (lParam & 0x00ff0000) >> 16;
int nCapture = 0;
if (nCode < 0)
return CallNextHookEx (hMouse, nCode, wParam, lParam);
if ((lParam & 0x0000ffff) == 1 && !(lParam & 0x20000000) &&
(lParam & 0x80000000))
{
if (nKey != lLastKey)
nCapture = 1; /* Capture this key */
else if (nKey != lLastKey2)
nCapture = 1; /* Allow for one repeat */
}
if (nCapture)
{
DWORD dwTimer = GetTickCount ();
DWORD j = dwLastTimer - dwTimer;
unsigned __int32 timeCrc = 0L;
int i;
dwLastTimer = dwTimer;
lLastKey2 = lLastKey;
lLastKey = nKey;
for (i = 0; i < 4; i++)
{
timeCrc = UPDC32 (((unsigned char *) &j)[i], timeCrc);
}
for (i = 0; i < 4; i++)
{
timeCrc = UPDC32 (((unsigned char *) &dwTimer)[i], timeCrc);
}
EnterCriticalSection (&critRandProt);
RandaddInt32 ((unsigned __int32) (GetCrc32((unsigned char*) &lParam, sizeof(lParam)) + timeCrc));
LeaveCriticalSection (&critRandProt);
}
return CallNextHookEx (hMouse, nCode, wParam, lParam);
}
unsigned long int crc32buf(const char *pBuffer, std::size_t nLength) {
unsigned long int oldcrc32;
oldcrc32 = 0xFFFFFFFF;
for (; nLength; --nLength, ++pBuffer) {
oldcrc32 = UPDC32(*pBuffer, oldcrc32);
}
return ~oldcrc32;
}
int crc32file( char *name ) {
FILE *fin;
unsigned long oldcrc32;
unsigned long crc32;
unsigned long oldcrc;
int c;
long charcnt;
long l;
oldcrc32 = 0xFFFFFFFF;
charcnt = 0;
if ((fin=fopen(name, "r"))==nullptr) {
perror(name);
return ERROR;
}
while ((c=getc(fin))!=EOF) {
++charcnt;
oldcrc32 = UPDC32(c, oldcrc32);
}
if (ferror(fin)) {
perror(name);
fclose(fin);
return ERROR;
} else {
if (Block) {
for (l = charcnt; l % Block; ++l) {
oldcrc32 = UPDC32(032, oldcrc32);
}
}
crc32 = oldcrc32;
oldcrc = oldcrc32 = ~oldcrc32;
printf("%08lX %7ld ", oldcrc, charcnt);
if (Block == 128) {
printf("%5ld+%3ld ", charcnt/Block, charcnt%Block);
}
if (Block == 1024) {
printf("%5ld+%4ld ", charcnt/Block, charcnt%Block);
}
std::clog << " " << name << "\n";
}
fclose( fin );
return OK;
}
/* Capture the mouse, and as long as the event is not the same as the last
two events, add the crc of the event, and the crc of the time difference
between this event and the last + the current time to the pool.
The role of CRC-32 is merely to perform diffusion. Note that the output
of CRC-32 is subsequently processed using a cryptographically secure hash
algorithm. */
LRESULT CALLBACK MouseProc (int nCode, WPARAM wParam, LPARAM lParam)
{
static DWORD dwLastTimer;
static unsigned __int32 lastCrc, lastCrc2;
MOUSEHOOKSTRUCT *lpMouse = (MOUSEHOOKSTRUCT *) lParam;
if (nCode < 0)
return CallNextHookEx (hMouse, nCode, wParam, lParam);
else
{
DWORD dwTimer = GetTickCount ();
DWORD j = dwLastTimer - dwTimer;
unsigned __int32 crc = 0L;
int i;
dwLastTimer = dwTimer;
for (i = 0; i < sizeof (MOUSEHOOKSTRUCT); i++)
{
crc = UPDC32 (((unsigned char *) lpMouse)[i], crc);
}
if (crc != lastCrc && crc != lastCrc2)
{
unsigned __int32 timeCrc = 0L;
for (i = 0; i < 4; i++)
{
timeCrc = UPDC32 (((unsigned char *) &j)[i], timeCrc);
}
for (i = 0; i < 4; i++)
{
timeCrc = UPDC32 (((unsigned char *) &dwTimer)[i], timeCrc);
}
EnterCriticalSection (&critRandProt);
RandaddInt32 ((unsigned __int32) (crc + timeCrc));
LeaveCriticalSection (&critRandProt);
}
lastCrc2 = lastCrc;
lastCrc = crc;
}
return 0;
}
unsigned long doFCS(unsigned char* buf, int len) {
int i;
unsigned long crc=0xffffffff;
for(i=0;i<len;i++) {
crc=UPDC32(buf[i],crc);
}
return(crc);
}
inline uint32_t crc32(uint32_t partial, const char* buf, size_t len)
{
/// TODO:
/// Consider algos from http://www.hackersdelight.org/hdcodetxt/crc.c.txt
static uint32_t crc_32_tab[] =
{ /* CRC polynomial 0xedb88320 */
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
#define UPDC32(octet, crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
for (; len; --len, ++buf)
partial = UPDC32(*buf, partial);
return partial;
#undef UPDC32
}
uint32 crc32(char *in, uint64 length){
register uint32 oldcrc32;
char *buf = in;
oldcrc32 = 0xFFFFFFFF;
for ( ; length; --length, ++buf) {
oldcrc32 = UPDC32(*buf, oldcrc32);
}
return ~oldcrc32; // Return inverted (NOT) value
}
uint32_t crc32(const char *buf, size_t len) {
uint32_t crc = 0xFFFFFFFF;
for (; len; --len, ++buf) {
crc = UPDC32(*buf, crc);
}
return crc;
}
uint32_t crc32buf(char *buf, size_t len)
{
uint32_t crc;
crc = 0xFFFFFFFF;
for (; len; --len, ++buf)
crc = UPDC32(*buf, crc);
return crc;
}
crc32 calc_crc32_buf(const void *buf, size_t n){
int i;
const char *buffer = (const char *)buf;
crc32 crc = ~0;
for (i = 0; i < n; i++)
crc = UPDC32(buffer[i], crc);
return ~crc;
}
/* Send ZMODEM binary header hdr of type type */
static void zsbh32(char *hdr, int type)
{
register int n;
register unsigned long crc;
xsendline(ZBIN32);
zsendline(type);
crc = 0xFFFFFFFFL;
crc = UPDC32(type, crc);
for (n = 4; --n >= 0; ++hdr) {
crc = UPDC32((0377 & *hdr), crc);
zsendline(*hdr);
}
crc = ~crc;
for (n = 4; --n >= 0;) {
zsendline((int) crc);
crc >>= 8;
}
}
uint32_t crc32buf(const char *buf)
{
uint32_t oldcrc32 = 0xFFFFFFFF;
for (const char* len = buf; len && *len != '\0'; ++len)
{
oldcrc32 = UPDC32(*len, oldcrc32);
}
return ~oldcrc32;
}
unsigned int crc32(char *buf, size_t len)
{
register unsigned int oldcrc32;
oldcrc32 = 0xFFFFFFFF;
for ( ; len; --len, ++buf)
{
oldcrc32 = UPDC32(*buf, oldcrc32);
}
return ~oldcrc32;
}
UINT32
compute_crc32 P2(unsigned char *, buf, int, len)
{
register UINT32 crc = 0xFFFFFFFFL;
register int j;
j = len;
while (j--) {
/* the UPDC32 macro uses 1st arg only once */
crc = UPDC32((unsigned int) *buf++, crc);
}
return crc;
}
wxUint32 Helpers::crc32buf(const char *buf, size_t len)
{
register wxUint32 oldcrc32;
oldcrc32 = 0xFFFFFFFF;
for ( ; len; --len, ++buf)
{
oldcrc32 = UPDC32(*buf, oldcrc32);
}
return ~oldcrc32;
}
u_int32_t crc32(const char *buf, int len)
{
u_int32_t result = 0xFFFFFFFF;
if( buf == NULL || len < 1 )
return result;
while(len--) {
result = UPDC32((u_int32_t) *buf++, result);
}
return result;
}
DWORD crc32pseudo()
{
int i;
register DWORD oldcrc32;
oldcrc32 = 0xFFFFFFFF;
for (i = 0 ; i < 1024; ++i)
{
oldcrc32 = UPDC32(rand(), oldcrc32);
}
return ~oldcrc32;
}
DWORD r3dCRC32(const BYTE* data, DWORD size)
{
DWORD crc32 = 0xFFFFFFFF;
#define UPDC32(octet,crc) (crc_32_tab[((crc) ^ ((BYTE)octet)) & 0xff] ^ ((crc) >> 8))
for(; size; --size, ++data) {
crc32 = UPDC32(*data, crc32);
}
#undef UPDC32
return ~crc32;
}
uint32_t crc32buf(char *buf, size_t len)
{
register uint32_t oldcrc32;
oldcrc32 = 0xFFFFFFFF;
for ( ; len; --len, ++buf)
{
oldcrc32 = UPDC32(*buf, oldcrc32);
}
return ~oldcrc32;
}
DWORD crc32buf(char *buf, size_t len)
{
register DWORD oldcrc32;
oldcrc32 = 0xFFFFFFFF;
for ( ; len; --len, ++buf)
{
oldcrc32 = UPDC32(*buf, oldcrc32);
PA_YieldAbsolute();
}
return ~oldcrc32;
}
unsigned long filecrc32(char * fname)
{
register unsigned long crc32;
register int i;
FILE *f;
crc32 = 0xFFFFFFFFl;
if ((f=fopen(fname, "rb"))==NULL)
return crc32;
while ((i=fgetc(f))!=EOF)
crc32 = UPDC32(i, crc32);
fclose(f);
return crc32;
}
uint32 crc32buffer(const uint8 *arBuffer, int arLen)
{
register uint32 oldcrc32;
register uint32 oldcrc;
uint8 c;
register int charcnt;
oldcrc32 = 0xFFFFFFFFL; charcnt = 0;
while(arLen) {
c = arBuffer[charcnt];
++charcnt;
--arLen;
oldcrc32 = UPDC32(c, oldcrc32);
}
oldcrc = oldcrc32 = ~oldcrc32;
return oldcrc;
}
static int zrdat32(char *buf, int length, size_t * bytes_received)
{
register int c;
register unsigned long crc;
register char *end;
register int d;
crc = 0xFFFFFFFFL;
end = buf + length;
while (buf <= end) {
if ((c = zdlread()) & ~0377) {
crcfoo:
switch (c) {
case GOTCRCE:
case GOTCRCG:
case GOTCRCQ:
case GOTCRCW:
d = c;
c &= 0377;
crc = UPDC32(c, crc);
if ((c = zdlread()) & ~0377)
goto crcfoo;
crc = UPDC32(c, crc);
if ((c = zdlread()) & ~0377)
goto crcfoo;
crc = UPDC32(c, crc);
if ((c = zdlread()) & ~0377)
goto crcfoo;
crc = UPDC32(c, crc);
if ((c = zdlread()) & ~0377)
goto crcfoo;
crc = UPDC32(c, crc);
if (crc != 0xDEBB20E3) {
return ERROR;
}
*bytes_received = length - (end - buf);
COUNT_BLK(*bytes_received);
return d;
case GOTCAN:
return ZCAN;
case TIMEOUT:
return c;
default:
return c;
}
}
*buf++ = c;
crc = UPDC32(c, crc);
}
return ERROR;
}
unsigned long int crc32str(char *name)
{
register unsigned int oldcrc32;
register unsigned int crc32;
register unsigned char c;
register int a=0;
oldcrc32 = 0;
while (name[a] != 0) {
c=name[a];
oldcrc32 = UPDC32(c, oldcrc32);
a++;
}
crc32 = oldcrc32; oldcrc32 = oldcrc32;
return crc32;
}
crc32 calc_crc32_fd(int fd)
{
int i, r;
unsigned char buffer[256];
crc32 crc = ~0;
off_t pos;
pos = lseek(fd, 0, SEEK_CUR);
lseek(fd, 0, SEEK_SET);
while ((r = read(fd, buffer, sizeof(buffer))) > 0)
{
for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc);
}
lseek(fd, pos, SEEK_SET);
return ~crc;
}
unsigned long crc32(char * str)
{
register unsigned long crc32;
crc32 = 0xFFFFFFFFl;
for (;*str;str++)
{
crc32 = UPDC32(*str, crc32);
}
/*
crc32 = UPDC32((oldcrc32 & 0377), crc32); oldcrc32 >>=8;
crc32 = UPDC32((oldcrc32 & 0377), crc32); oldcrc32 >>=8;
crc32 = UPDC32((oldcrc32 & 0377), crc32); oldcrc32 >>=8;
crc32 = UPDC32((oldcrc32 & 0377), crc32); oldcrc32 >>=8;
printf("%08lX ", crc32);
*/
return crc32;
}
int crc32file(char *name, DWORD *crc) {
register FILE *fin;
register DWORD oldcrc32;
register int c;
oldcrc32 = 0xFFFFFFFF;
if ((fin=fopen(name, "rb"))==NULL) {
perror(name);
return -1;
}
while ((c = getc(fin)) != EOF) {
oldcrc32 = UPDC32(c, oldcrc32);
}
if (ferror(fin)) {
perror(name);
}
fclose(fin);
*crc = oldcrc32 = ~oldcrc32;
return 0;
}
int crc32file (char *name)
{
register FILE *fin;
register unsigned long crc32;
register unsigned short ccitt, crc16;
register int c;
register long charcnt;
crc32 = 0xFFFFFFFF; ccitt = 0xFFFF;
crc16 = charcnt = 0;
if ((fin=fopen(name, "rb"))==NULL)
{
perror(name);
return ERROR;
}
while ((c=getc(fin))!=EOF) {
++charcnt;
crc32 = UPDC32(c, crc32);
ccitt = UPDCIT(c, ccitt);
crc16 = UPDC16(c, crc16);
}
if (ferror(fin))
{
perror(name);
fclose(fin); return ERROR;
}
else
{
crc32 = ~crc32;
ccitt = ~ccitt;
printf(" %08lX %04X %04X%10ld %s\n",
crc32, ccitt, crc16, charcnt, name);
}
fclose(fin); return OK;
}
Boolean_T crc32file(char *name, DWORD *crc, long *charcnt)
{
// FB -- change to make the benchmark use stdio without command-line args
register FILE *fin = stdin;
register DWORD oldcrc32;
register int c;
oldcrc32 = 0xFFFFFFFF; *charcnt = 0;
#ifdef MSDOS
// FB -- change to make the benchmark use stdio without command-line args
if (name != NULL && (fin=fopen(name, "rb"))==NULL)
#else
// FB -- change to make the benchmark use stdio without command-line args
if (name != NULL && (fin=fopen(name, "r"))==NULL)
#endif
{
perror(name);
return Error_;
}
while ((c=getc(fin))!=EOF)
{
++*charcnt;
oldcrc32 = UPDC32(c, oldcrc32);
}
if (ferror(fin))
{
perror(name);
*charcnt = -1;
}
fclose(fin);
*crc = oldcrc32 = ~oldcrc32;
return Success_;
}