"{ Encoding: utf8 }"

"{ Package: 'stx:libbasic2' }"

"{ NameSpace: Smalltalk }"

HashStream subclass:#CRCStream

	instanceVariableNames:'crc generatorPolynom crcTable initValue xorOut'

	classVariableNames:''

	poolDictionaries:''

	category:'System-Crypt-Hashing'

!

CRCStream class instanceVariableNames:'crcTables'

"

 No other class instance variables are inherited by this class.

"

!

!CRCStream class methodsFor:'documentation'!

documentation

"

    abstract superclass of crc streams;

    refactored from original crc32 stream.

    For details, see https://en.wikipedia.org/wiki/Cyclic_redundancy_check

    Only use CRC to protect against communication errors;

    DO NOT use CRC for cryptography, authentication, security, etc.

    - use secure hashes for those instead.

    [parameters:] 

        polynomials:

            CRC_POLY_16             0xA001

            CRC_POLY_32             0xEDB88320L

            CRC_POLY_CCITT          0x1021

            CRC_POLY_DNP            0xA6BC

            CRC_POLY_KERMIT         0x8408

        start values:

            CRC_START_8             0x00

            CRC_START_16            0x0000

            CRC_START_MODBUS        0xFFFF

            CRC_START_XMODEM        0x0000

            CRC_START_CCITT_1D0F    0x1D0F

            CRC_START_CCITT_FFFF    0xFFFF

            CRC_START_KERMIT        0x0000

            CRC_START_SICK          0x0000

            CRC_START_DNP           0x0000

            CRC_START_32            0xFFFFFFFF

"

! !

!CRCStream class methodsFor:'initialization'!

crcTableFor:generatorPolynomInteger

    "construct the polynom-specific lookup table"

    |crcTable|

    "/ CRC8Stream flushCrcTables

    "/ CRC8Stream crcTableFor:(16r1D bitReversed8)

    crcTables isNil ifTrue:[

        crcTables := Dictionary new

    ].    

    crcTable := (crcTables at:generatorPolynomInteger ifAbsent:nil).

    crcTable isNil ifTrue:[

        "/ for crc16 and crc8, we waste some memory 

        "/ (could use WordArray or ByteArray);

        "/ but that would need three writeBytes implementations.

        "/ Not worth the saving.

        crcTable := IntegerArray new:256.

        "/ least-sign. bit towards most significant bit...

        0 to:255 do:[:count| |i|

            i := count.

            8 timesRepeat:[

                (i bitTest:1) ifTrue:[

                    i := generatorPolynomInteger bitXor:(i bitShift:-1)

                ] ifFalse:[

                    i := i bitShift:-1

                ]

            ].

            crcTable at:count+1 put:i.

        ].

        crcTables at:generatorPolynomInteger put:crcTable.

    ].

    ^ crcTable.

    "Created: / 16-03-2019 / 20:53:51 / Claus Gittinger"

    "Modified: / 24-03-2019 / 12:38:12 / Claus Gittinger"

!

flushCrcTables

    crcTables := nil.

    "

     CRC16Stream flushCrcTables

     CRC32Stream flushCrcTables

    "

    "Created: / 16-03-2019 / 23:41:19 / Claus Gittinger"

! !

!CRCStream class methodsFor:'instance creation'!

generatorPolynom:anLSBInteger

    "notice, in literature, the generator polynom is usually specified as an MSB number"

    ^ self basicNew 

        generatorPolynom:anLSBInteger

    "

       self assert:((self generatorPolynom:16r82F63B78)

                                nextPut:'123456789';

                                hashValue)    = 16rE3069283

    "

    "Modified (format): / 17-03-2019 / 14:03:42 / Claus Gittinger"

!

generatorPolynom:anLSBInteger initValue:initValue

    "notice, in literature, the generator polynom is usually specified as an MSB number"

    ^ self basicNew 

        generatorPolynom:anLSBInteger 

        initValue:initValue

    "

       self assert:((self generatorPolynom:16r82F63B78)

                                nextPut:'123456789';

                                hashValue)    = 16rE3069283

    "

    "Created: / 16-03-2019 / 21:15:54 / Claus Gittinger"

    "Modified (format): / 17-03-2019 / 14:03:37 / Claus Gittinger"

!

generatorPolynom:anLSBInteger initValue:initValue xorOut:xorOut

    "notice, in literature, the generator polynom is usually specified as an MSB number"

    ^ self basicNew 

        generatorPolynom:anLSBInteger 

        initValue:initValue xorOut:xorOut

    "

       self assert:((self generatorPolynom:16r82F63B78)

                                nextPut:'123456789';

                                hashValue)    = 16rE3069283

    "

    "Created: / 16-03-2019 / 21:16:05 / Claus Gittinger"

    "Modified (format): / 17-03-2019 / 14:03:30 / Claus Gittinger"

! !

!CRCStream methodsFor:'accessing'!

generatorPolynom

    "answer the generator polynom (LSB)"

    ^ generatorPolynom

    "Modified (comment): / 16-03-2019 / 20:58:10 / Claus Gittinger"

!

initValue

    "answer the init value"

    ^ initValue ? 0

    "Created: / 16-03-2019 / 21:05:04 / Claus Gittinger"

!

xorOut

    "answer the xorOut value"

    ^ xorOut ? 16rFFFFFFFF

    "Created: / 16-03-2019 / 21:16:23 / Claus Gittinger"

! !

!CRCStream methodsFor:'initialization'!

generatorPolynom:polyLSB initValue:initValueArg xorOut:xorOutArg

    "set the generator polynom for this instance.

     And set start and xorOut.

     Computes the crcTable for this polynom.

     Notice the bit order is LSB"

    generatorPolynom := polyLSB.

    crc := initValue := initValueArg.

    xorOut := xorOutArg.

    crcTable := self class crcTableFor:generatorPolynom.

    "Created: / 16-03-2019 / 21:17:12 / Claus Gittinger"

    "Modified (comment): / 17-03-2019 / 12:25:11 / Claus Gittinger"

!

reset

    "reset the current crc value"

    crc := initValue.

    "Created: / 16-03-2019 / 21:25:27 / Claus Gittinger"

! !

!CRCStream methodsFor:'queries'!

hashValue

    "return the computed CRC"

    ^ crc bitXor:xorOut.

    "Modified: / 16-03-2019 / 21:27:59 / Claus Gittinger"

! !

!CRCStream methodsFor:'writing'!

nextPutBytes:count from:anObject startingAt:start

    "add the hash of anObject to the computed hash so far."

%{

    int len, offs;

    // fetch first - check later

    len = __intVal(count);

    offs = __intVal(start) - 1;

    if (__bothSmallInteger(count, start)) {

        int objSize;

        unsigned char *extPtr;

        // the most common first

        if (__isStringLike(anObject)) {

            objSize = __stringSize(anObject);

            extPtr = (unsigned char *)__stringVal(anObject);

        } else if (__isByteArray(anObject)) {

            objSize = __byteArraySize(anObject);

            extPtr = (unsigned char *)__byteArrayVal(anObject);

        } else if (__isExternalBytesLike(anObject)) {

            OBJ sz = __externalBytesSize(anObject);

            extPtr = (unsigned char *)__externalBytesAddress(anObject);

            if (__isSmallInteger(sz)) {

                objSize = __intVal(sz);

            } else {

                objSize = 0; /* unknown */

            }

        } else {

            int nInstVars, nInstBytes;

            OBJ oClass = __Class(anObject);

            switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {

                case BYTEARRAY:

                case WORDARRAY:

                case LONGARRAY:

                case SWORDARRAY:

                case SLONGARRAY:

                case FLOATARRAY:

                case DOUBLEARRAY:

                    break;

                default:

                    goto bad;

            }

            nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);

            nInstBytes = __OBJS2BYTES__(nInstVars);

            // nInstBytes is the number of bytes occupied by pointer instance variables

            // subtract from size and add to byte-pointer

            objSize = __qSize(anObject) - OHDR_SIZE - nInstBytes;

            extPtr = (unsigned char *)__byteArrayVal(anObject)+nInstBytes;

        }

        if ((offs >= 0) && (len >= 0) && (objSize >= (len + offs))) {

            unsigned int _crc;

            unsigned int *_crcTable = __integerArrayVal( __INST(crcTable) );

            unsigned char *cp = extPtr+offs;

            unsigned int n = len;

            _crc = (unsigned int) (__intVal( __INST(crc) ));

#if __POINTER_SIZE__ != 8

            if (!__isSmallInteger(__INST(crc))) {

                _crc = __unsignedLongIntVal( __INST(crc) );

            }

#endif

#ifdef __LSBFIRST__

# if __POINTER_SIZE__ == 8

            if (((unsigned INT)cp & 7) == 0) {

                // longword aligned

                for ( ; n >= 8 ; n -= 8, cp += 8) {

                    unsigned INT lWord;

                    unsigned char _idx;

                    lWord = ((unsigned INT *)cp)[0];

                    _idx = (_crc ^ lWord) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (lWord>>8)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (lWord>>16)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (lWord>>24)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (lWord>>32)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (lWord>>40)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (lWord>>48)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (lWord>>56)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                }

            }

# endif // __POINTER_SIZE__ == 8          

            if (((unsigned INT)cp & 3) == 0) {

                // word aligned

                for ( ; n >= 4 ; n -= 4, cp += 4) {

                    unsigned int word;

                    unsigned char _idx;

                    word = ((unsigned int *)cp)[0];

                    _idx = (_crc ^ word) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (word>>8)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (word>>16)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                    _idx = (_crc ^ (word>>24)) & 0xFF;

                    _crc = _crcTable[_idx] ^ (_crc >> 8);

                }

            }

#endif // LSBFIRST

            for ( ; n >= 4 ; n -= 4, cp += 4) {

                unsigned char _idx;

                _idx = (_crc ^ cp[0]) & 0xFF;

                _crc = _crcTable[_idx] ^ (_crc >> 8);

                _idx = (_crc ^ cp[1]) & 0xFF;

                _crc = _crcTable[_idx] ^ (_crc >> 8);

                _idx = (_crc ^ cp[2]) & 0xFF;

                _crc = _crcTable[_idx] ^ (_crc >> 8);

                _idx = (_crc ^ cp[3]) & 0xFF;

                _crc = _crcTable[_idx] ^ (_crc >> 8);

            }

            while (n-- > 0) {

                unsigned char _idx = (_crc ^ *cp++) & 0xFF;

                _crc = _crcTable[_idx] ^ (_crc >> 8);

            }

#if __POINTER_SIZE__ == 8

            __INST(crc) = __MKSMALLINT(_crc);

#else

            if (_crc <= _MAX_INT) {

                __INST(crc) = __MKSMALLINT(_crc);

            } else {

                // this code fails with gcc 4.7.2:

                // __INST(crc) = __MKUINT(_crc); __STORESELF(crc);

                OBJ temp = __MKUINT(_crc); 

                __INST(crc) = temp; __STORESELF(crc);

            }

#endif

            RETURN (count);

        }

    }

bad: ;

%}.

    ArgumentError raise

    "Created: / 09-01-2012 / 16:48:35 / cg"

    "Modified: / 06-06-2019 / 23:16:48 / Claus Gittinger"

! !

!CRCStream class methodsFor:'documentation'!

version_CVS

    ^ '$Header$'

! !