I'm having a hard time finding a java implementation of CRC32C checksum.
There are some C versions from linux that I have found and attempted to convert to Java, but with no success yet. Anyone know of some existing code or be willing to at my code to help me figure out what I'm doing wrong?
Thanks,
Eric
It's something like:import java.util.zip.CRC32;
class Foo {
public static void main(String[] args) {
CRC32 crc32 = new CRC32();
crc32.update(/*some byte array to calculate checksum for*/):
long crc32value = crc32.getValue();
System.out.println(crc32value);
}
}
Enjoy!
> It's something like:[code]import
> java.util.zip.CRC32;
>
> class Foo {
>public static void main(String[] args) {
>CRC32 crc32 = new CRC32();
> crc32.update(/*some byte array to calculate
> checksum for*/):
>long crc32value = crc32.getValue();
> System.out.println(crc32value);
>}
> code]Enjoy!
Unfortunately, I'm looking for CRC32C not just CRC32. But thanks for the suggestion
Eric
Oops, sorry didn't notice the trailing 'c'. The posts I made were regarding the CRC32 checksum. CRC32C is very similar, you could take a look at the implementation of the java.util.zip.CRC32 and use it to write your own CRC32C implementation. Post specific questions here if you run into trouble.
Good luck!
> Oops, sorry didn't notice the trailing 'c'. The posts
> I made were regarding the CRC32 checksum. CRC32C is
> very similar, you could take a look at the
> implementation of the java.util.zip.CRC32 and use it
> to write your own CRC32C implementation. Post
> specific questions here if you run into trouble.
> Good luck!
Well, sorry again, that won't work since the implementation is compiled as native code. Well, you could still post what you've got so far and I (or someone else) can try to help you.
Here is the code that I have. It uses this table method since that is
supposed to perform better. This is base on c code at the following
link, (which is in the linux kernel):
http://www.ussg.iu.edu/hypermail/linux/kernel/0404.3/0864.html
Thanks,
Eric
static final long crc_c[] = {
0x00000000L, 0xF26B8303L, 0xE13B70F7L, 0x1350F3F4L,
0xC79A971FL, 0x35F1141CL, 0x26A1E7E8L, 0xD4CA64EBL,
0x8AD958CFL, 0x78B2DBCCL, 0x6BE22838L, 0x9989AB3BL,
0x4D43CFD0L, 0xBF284CD3L, 0xAC78BF27L, 0x5E133C24L,
0x105EC76FL, 0xE235446CL, 0xF165B798L, 0x030E349BL,
0xD7C45070L, 0x25AFD373L, 0x36FF2087L, 0xC494A384L,
0x9A879FA0L, 0x68EC1CA3L, 0x7BBCEF57L, 0x89D76C54L,
0x5D1D08BFL, 0xAF768BBCL, 0xBC267848L, 0x4E4DFB4BL,
0x20BD8EDEL, 0xD2D60DDDL, 0xC186FE29L, 0x33ED7D2AL,
0xE72719C1L, 0x154C9AC2L, 0x061C6936L, 0xF477EA35L,
0xAA64D611L, 0x580F5512L, 0x4B5FA6E6L, 0xB93425E5L,
0x6DFE410EL, 0x9F95C20DL, 0x8CC531F9L, 0x7EAEB2FAL,
0x30E349B1L, 0xC288CAB2L, 0xD1D83946L, 0x23B3BA45L,
0xF779DEAEL, 0x05125DADL, 0x1642AE59L, 0xE4292D5AL,
0xBA3A117EL, 0x4851927DL, 0x5B016189L, 0xA96AE28AL,
0x7DA08661L, 0x8FCB0562L, 0x9C9BF696L, 0x6EF07595L,
0x417B1DBCL, 0xB3109EBFL, 0xA0406D4BL, 0x522BEE48L,
0x86E18AA3L, 0x748A09A0L, 0x67DAFA54L, 0x95B17957L,
0xCBA24573L, 0x39C9C670L, 0x2A993584L, 0xD8F2B687L,
0x0C38D26CL, 0xFE53516FL, 0xED03A29BL, 0x1F682198L,
0x5125DAD3L, 0xA34E59D0L, 0xB01EAA24L, 0x42752927L,
0x96BF4DCCL, 0x64D4CECFL, 0x77843D3BL, 0x85EFBE38L,
0xDBFC821CL, 0x2997011FL, 0x3AC7F2EBL, 0xC8AC71E8L,
0x1C661503L, 0xEE0D9600L, 0xFD5D65F4L, 0x0F36E6F7L,
0x61C69362L, 0x93AD1061L, 0x80FDE395L, 0x72966096L,
0xA65C047DL, 0x5437877EL, 0x4767748AL, 0xB50CF789L,
0xEB1FCBADL, 0x197448AEL, 0x0A24BB5AL, 0xF84F3859L,
0x2C855CB2L, 0xDEEEDFB1L, 0xCDBE2C45L, 0x3FD5AF46L,
0x7198540DL, 0x83F3D70EL, 0x90A324FAL, 0x62C8A7F9L,
0xB602C312L, 0x44694011L, 0x5739B3E5L, 0xA55230E6L,
0xFB410CC2L, 0x092A8FC1L, 0x1A7A7C35L, 0xE811FF36L,
0x3CDB9BDDL, 0xCEB018DEL, 0xDDE0EB2AL, 0x2F8B6829L,
0x82F63B78L, 0x709DB87BL, 0x63CD4B8FL, 0x91A6C88CL,
0x456CAC67L, 0xB7072F64L, 0xA457DC90L, 0x563C5F93L,
0x082F63B7L, 0xFA44E0B4L, 0xE9141340L, 0x1B7F9043L,
0xCFB5F4A8L, 0x3DDE77ABL, 0x2E8E845FL, 0xDCE5075CL,
0x92A8FC17L, 0x60C37F14L, 0x73938CE0L, 0x81F80FE3L,
0x55326B08L, 0xA759E80BL, 0xB4091BFFL, 0x466298FCL,
0x1871A4D8L, 0xEA1A27DBL, 0xF94AD42FL, 0x0B21572CL,
0xDFEB33C7L, 0x2D80B0C4L, 0x3ED04330L, 0xCCBBC033L,
0xA24BB5A6L, 0x502036A5L, 0x4370C551L, 0xB11B4652L,
0x65D122B9L, 0x97BAA1BAL, 0x84EA524EL, 0x7681D14DL,
0x2892ED69L, 0xDAF96E6AL, 0xC9A99D9EL, 0x3BC21E9DL,
0xEF087A76L, 0x1D63F975L, 0x0E330A81L, 0xFC588982L,
0xB21572C9L, 0x407EF1CAL, 0x532E023EL, 0xA145813DL,
0x758FE5D6L, 0x87E466D5L, 0x94B49521L, 0x66DF1622L,
0x38CC2A06L, 0xCAA7A905L, 0xD9F75AF1L, 0x2B9CD9F2L,
0xFF56BD19L, 0x0D3D3E1AL, 0x1E6DCDEEL, 0xEC064EEDL,
0xC38D26C4L, 0x31E6A5C7L, 0x22B65633L, 0xD0DDD530L,
0x0417B1DBL, 0xF67C32D8L, 0xE52CC12CL, 0x1747422FL,
0x49547E0BL, 0xBB3FFD08L, 0xA86F0EFCL, 0x5A048DFFL,
0x8ECEE914L, 0x7CA56A17L, 0x6FF599E3L, 0x9D9E1AE0L,
0xD3D3E1ABL, 0x21B862A8L, 0x32E8915CL, 0xC083125FL,
0x144976B4L, 0xE622F5B7L, 0xF5720643L, 0x07198540L,
0x590AB964L, 0xAB613A67L, 0xB831C993L, 0x4A5A4A90L,
0x9E902E7BL, 0x6CFBAD78L, 0x7FAB5E8CL, 0x8DC0DD8FL,
0xE330A81AL, 0x115B2B19L, 0x020BD8EDL, 0xF0605BEEL,
0x24AA3F05L, 0xD6C1BC06L, 0xC5914FF2L, 0x37FACCF1L,
0x69E9F0D5L, 0x9B8273D6L, 0x88D28022L, 0x7AB90321L,
0xAE7367CAL, 0x5C18E4C9L, 0x4F48173DL, 0xBD23943EL,
0xF36E6F75L, 0x0105EC76L, 0x12551F82L, 0xE03E9C81L,
0x34F4F86AL, 0xC69F7B69L, 0xD5CF889DL, 0x27A40B9EL,
0x79B737BAL, 0x8BDCB4B9L, 0x988C474DL, 0x6AE7C44EL,
0xBE2DA0A5L, 0x4C4623A6L, 0x5F16D052L, 0xAD7D5351L
};
static long CRC32C(long c, byte d) {
//int crc (c=(c>>8)^crc_c[(c^(d))&0xFF])
long tableIndex = (c^((int)d & 0xff)) & 0xff;
long cShift8 = (c>>>8) & 0x00ffffff;
long tableValue = crc_c[(int)tableIndex];
long crc = (cShift8^tableValue);
return crc;
}
public static long calculateCRC32C(byte[] data) {
// seed the crc value
long crc = -1; //0x00000000ffffffffL;
for (byte b : data) {
crc = CRC32C(crc, b);
}
return crc;
}
Well, I've got some test data and it seems that I'm getting the wrong results.
But then again, maybe the test data is bad? If you know of a good source for
test data for CRC32C, that would be great. Here is the test data and the results that I am supposed to get:
byte[] rawData = {0x01, (byte)0xC0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x01, (byte)0xFE, 60, (byte)0xAC,
0x00, 0x00, 0x00, 0x08,
0x00, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x09,
0x25, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
// this should result in 148AB099
I got this test data from a com trace of some hardware that is
supposed to automatically generate the CRC32C, but maybe it's
wrong? Doesn't seem likely, but you never know
Thanks,
Eric
> long crc = -1; //0x00000000ffffffffL;
> You might want to check,
> but I'm almost certain that the widening conversion
> will sign-extend 0xffffffff to 0xffffffffffffffff.
It will. To OP, when you want a specific long hex value, write it like so: 0xffffffffL
~Cheers
Thanks for the suggestion, but it unfortunately did not make a difference.
I tried long crc = 0xffffffffL, crc=-1, and crc=0x00000000ffffffffL. All gave the
same results.
I think I'll try running my test data against the c version of the code and see what the results are. In the meantime any suggestions are welcome.
Thanks,
Eric
I suspect your test is invalid. Using the 'C' program (heart obtainable from various sources on the web)
/* SCTP kernel reference Implementation
* Copyright (c) 1999-2001 Motorola, Inc.
* Copyright (c) 2001-2003 International Business Machines, Corp.
*
* This file is part of the SCTP kernel reference Implementation
*
* SCTP Checksum functions
*
* The SCTP reference implementation is free software;
* you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* The SCTP reference implementation is distributed in the hope that it
* will be useful, but WITHOUT ANY WARRANTY; without even the implied
*************************
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU CC; see the file COPYING. If not, write to
* the Free Software Foundation, 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
* Please send any bug reports or fixes you make to the
* email address(es):
*lksctp developers <lksctp-developers@lists.sourceforge.net>
*
* Or submit a bug report through the following website:
*http://www.sf.net/projects/lksctp
*
* Written or modified by:
*Dinakaran Joseph
*Jon Grimm <jgrimm@us.ibm.com>
*Sridhar Samudrala <sri@us.ibm.com>
*
* Any bugs reported given to us we will try to fix... any fixes shared will
* be incorporated into the next SCTP release.
*/
/* The following code has been taken directly from
* draft-ietf-tsvwg-sctpcsum-03.txt
*
* The code has now been modified specifically for SCTP knowledge.
*/
#include <linux/types.h>
#import <stdio.h>
#define CRC32C_POLY 0x1EDC6F41
#define CRC32C(c,d) (c=(c>>8)^crc_c[(c^(d))&0xFF])
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Copyright 2001, D. Otis. Use this program, code or tables*/
/* extracted from it, as desired without restriction.*/
/**/
/* 32 Bit Reflected CRC table generation for SCTP.*/
/* To accommodate serial byte data being shifted out least*/
/* significant bit first, the table's 32 bit words are reflected */
/* which flips both byte and bit MS and LS positions. The CRC*/
/* is calculated MS bits first from the perspective of the serial*/
/* stream. The x^32 term is implied and the x^0 term may also*/
/* be shown as +1. The polynomial code used is 0x1EDC6F41.*/
/* Castagnoli93 */
/* x^32+x^28+x^27+x^26+x^25+x^23+x^22+x^20+x^19+x^18+x^14+x^13+ */
/* x^11+x^10+x^9+x^8+x^6+x^0 */
/* Guy Castagnoli Stefan Braeuer and Martin Herrman */
/* "Optimization of Cyclic Redundancy-Check Codes*/
/* with 24 and 32 Parity Bits", */
/* IEEE Transactions on Communications, Vol.41, No.6, June 1993 */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
__u32 crc_c[256] = {
0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
};
__u32 sctp_update_cksum(__u8 *buffer, __u16 length, __u32 crc32)
{
__u32 i;
for (i = 0; i < length ; i++)
CRC32C(crc32, buffer[i]);
return crc32;
}
__u8 test_data[48] = {
0x01, 0xC0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x01, 0xFE, 0x60, 0xAC,
0x00, 0x00, 0x00, 0x08,
0x00, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x09,
0x25, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
int main( int argc, char * argv[] )
{
__u32 crc32c = ~0;
printf("Hello World\n");
crc32c = sctp_update_cksum(test_data, 48, crc32c);
printf("Hello World\n");
printf("0x%x\n", crc32c);
}
which is cut down from a Linux implementaiton I get as result
0x664f75eb
and using the Java program
public class CRC32CDelegate
{
public int getCRC32()
{
return crc32;
}
private int crc32 = ~0;
private void CRC32C(byte d)
{
crc32 = (crc32>>>8)^crc_c[(crc32^d)&0xFF];
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Copyright 2001, D. Otis. Use this program, code or tables*/
/* extracted from it, as desired without restriction.*/
/**/
/* 32 Bit Reflected CRC table generation for SCTP.*/
/* To accommodate serial byte data being shifted out least*/
/* significant bit first, the table's 32 bit words are reflected */
/* which flips both byte and bit MS and LS positions. The CRC*/
/* is calculated MS bits first from the perspective of the serial*/
/* stream. The x^32 term is implied and the x^0 term may also*/
/* be shown as +1. The polynomial code used is 0x1EDC6F41.*/
/* Castagnoli93 */
/* x^32+x^28+x^27+x^26+x^25+x^23+x^22+x^20+x^19+x^18+x^14+x^13+ */
/* x^11+x^10+x^9+x^8+x^6+x^0 */
/* Guy Castagnoli Stefan Braeuer and Martin Herrman */
/* "Optimization of Cyclic Redundancy-Check Codes*/
/* with 24 and 32 Parity Bits", */
/* IEEE Transactions on Communications, Vol.41, No.6, June 1993 */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
private static final int crc_c[] = {
0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
};
void update(byte[] buffer, int length)
{
for (int i = 0; i < length ; i++)
CRC32C(buffer[i]);
}
public static void main(String[] args)
{
byte[] rawData = {
0x01, (byte)0xC0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x01, (byte)0xFE, 0x60, (byte)0xAC,
0x00, 0x00, 0x00, 0x08,
0x00, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x09,
0x25, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
CRC32CDelegate delegate = new CRC32CDelegate();
delegate.update(rawData, rawData.length);
System.out.println(Integer.toHexString(delegate.getCRC32()));
}
}
I get the same result.
Thanks for trying this out in C also. I also get the same results as you do
for the Java program. One thing that seems strange to me, however, is a second test that I ran. I believe by definition, if you have some test data, such as
byte[] rawData = {
0x01, (byte)0xC0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x01, (byte)0xFE, 0x60, (byte)0xAC,
0x00, 0x00, 0x00, 0x08,
0x00, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x09,
0x25, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
and get the results, in this case 0x664f75eb, that you should be able
to append that result to the original data, run the test again and get a result of 0.
When I run with the updated test data:
byte[] rawData = {
0x01, (byte)0xC0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x01, (byte)0xFE, 0x60, (byte)0xAC,
0x00, 0x00, 0x00, 0x08,
0x00, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x09,
0x25, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x66, 0x4f, 0x75, (byte)0xeb
};
I don't get 0 as a result. Instead I get 0x239a4dba. Am I misunderstanding
something about how CRC32C works, or is there a problem with the code?
Thanks,
Eric
I just thought of something. I tried byte swapping the result
from the first test and adding it to resulting test data like this:
byte[] rawData = {
0x01, (byte)0xC0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x01, (byte)0xFE, 0x60, (byte)0xAC,
0x00, 0x00, 0x00, 0x08,
0x00, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x09,
0x25, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
(byte)0xeb, 0x75, 0x4f, 0x66
};
and got a result of 0. So, maybe I have to byte swap the result?
If that's the case, is the test data in network (big endian) order? or does
it need to be swapped also, perhaps? I'll try that and see what happens
Thanks,
Eric
> and get the results, in this case 0x664f75eb, that
> you should be able
> to append that result to the original data, run the
> test again and get a result of 0.
No!
<snip>
> Am I misunderstanding
> omething about how CRC32C works, or is there a
> problem with the code?
You are 'misunderstanding somthing'!
> I suspect your test is invalid. Using the 'C' program
> (heart obtainable from various sources on the web)
> > /* SCTP kernel reference Implementation
> * Copyright (c) 1999-2001 Motorola, Inc.
> * Copyright (c) 2001-2003 International Business
> Machines, Corp.
> *
> * This file is part of the SCTP kernel reference
> Implementation
> *
> * SCTP Checksum functions
> *
> * The SCTP reference implementation is free software;
>
> * you can redistribute it and/or modify it under the
> terms of
> * the GNU General Public License as published by
> * the Free Software Foundation; either version 2, or
> (at your option)
> * any later version.
> *
> * The SCTP reference implementation is distributed in
> the hope that it
> * will be useful, but WITHOUT ANY WARRANTY; without
> even the implied
> *************************
> * warranty of MERCHANTABILITY or FITNESS FOR A
> PARTICULAR PURPOSE.
> * See the GNU General Public License for more
> details.
> *
> * You should have received a copy of the GNU General
> Public License
> * along with GNU CC; see the file COPYING. If not,
> write to
> * the Free Software Foundation, 59 Temple Place -
> Suite 330,
> * Boston, MA 02111-1307, USA.
> *
> * Please send any bug reports or fixes you make to
> the
> * email address(es):
> *lksctp developers
> <lksctp-developers@lists.sourceforge.net>
> *
> * Or submit a bug report through the following
> website:
> *http://www.sf.net/projects/lksctp
> *
> * Written or modified by:
> *Dinakaran Joseph
> *Jon Grimm <jgrimm@us.ibm.com>
> *Sridhar Samudrala <sri@us.ibm.com>
> *
> * Any bugs reported given to us we will try to
> fix... any fixes shared will
> * be incorporated into the next SCTP release.
> */
>
> /* The following code has been taken directly from
> * draft-ietf-tsvwg-sctpcsum-03.txt
> *
> * The code has now been modified specifically for
> SCTP knowledge.
> */
>
> #include <linux/types.h>
> #import <stdio.h>
>
> #define CRC32C_POLY 0x1EDC6F41
> #define CRC32C(c,d) (c=(c>>8)^crc_c[(c^(d))&0xFF])
> /* * * * * * * * * * * * * * * * * * * * * * * * * *
> * * * * * * */
> /* Copyright 2001, D. Otis. Use this program, code
> or tables*/
> /* extracted from it, as desired without restriction.
>*/
>
> /
> /* 32 Bit Reflected CRC table generation for SCTP.
>*/
> ate serial byte data being shifted out least
>*/
> nificant bit first, the table's 32 bit words are
> reflected */
> /* which flips both byte and bit MS and LS positions.
> The CRC*/
> * is calculated MS bits first from the perspective of
> the serial*/
> /* stream. The x^32 term is implied and the x^0 term
> may also*/
> /* be shown as +1. The polynomial code used is
> 0x1EDC6F41.*/
> /* Castagnoli93
> */
> ^18+x^14+x^13+ */
> /* x^11+x^10+x^9+x^8+x^6+x^0
> */
> Martin Herrman */
> * "Optimization of Cyclic Redundancy-Check Codes
>*/
> 32 Parity Bits", */
> /* IEEE Transactions on Communications, Vol.41, No.6,
> June 1993 */
> /* * * * * * * * * * * * * * * * * * * * * * * * * *
> * * * * * * */
> __u32 crc_c[256] = {
> 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
> 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
> 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
> 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
> 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
> 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
> 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
> 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
> 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
> 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
> 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
> 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
> 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
> 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
> 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
> 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
> 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
> 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
> 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
> 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
> 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
> 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
> 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
> 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
> 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
> 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
> 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
> 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
> 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
> 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
> 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
> 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
> 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
> 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
> 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
> 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
> 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
> 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
> 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
> 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
> 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
> 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
> 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
> 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
> 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
> 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
> 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
> 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
> 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
> 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
> 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
> 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
> 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
> 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
> 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
> 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
> 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
> 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
> 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
> 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
> 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
> 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
> 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
> 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
> };
>
> sctp_update_cksum(__u8 *buffer, __u16 length, __u32
> crc32)
>
> __u32 i;
>
> for (i = 0; i < length ; i++)
> CRC32C(crc32, buffer[i]);
>
> return crc32;
> }
>
> __u8 test_data[48] = {
>0x01, 0xC0, 0x00, 0x00,
> 0x00, 0x00, 0x00, 0x00,
>0x00, 0x00, 0x00, 0x00,
> 0x00, 0x00, 0x00, 0x00,
>0x01, 0xFE, 0x60, 0xAC,
> 0x00, 0x00, 0x00, 0x08,
>0x00, 0x00, 0x00, 0x04,
> 0x00, 0x00, 0x00, 0x09,
>0x25, 0x00, 0x00, 0x00,
> 0x00, 0x00, 0x00, 0x00,
>0x00, 0x00, 0x00, 0x00,
> 0x00, 0x00, 0x00, 0x00,
> };
>
> main( int argc, char * argv[] )
> {
>__u32 crc32c = ~0;
>printf("Hello World\n");
> crc32c = sctp_update_cksum(test_data, 48,
> crc32c);
>printf("Hello World\n");
> printf("0x%x\n", crc32c);
>
>
>
> which is cut down from a Linux implementaiton I get
> as result
> 0x664f75eb
> and using the Java program
> [code]
>
> public class CRC32CDelegate
> {
>public int getCRC32()
> {
> return crc32;
>
> private int crc32 = ~0;
>
> vate void CRC32C(byte d)
>{
>crc32 = (crc32>>>8)^crc_c[(crc32^d)&0xFF];
> }
>
> /* * * * * * * * * * * * * * * * * * * * * * * * * *
> * * * * * * */
> /* Copyright 2001, D. Otis. Use this program,
> code or tables*/
> /* extracted from it, as desired without
> restriction.*/
> /*
>
> /
> /* 32 Bit Reflected CRC table generation for
> SCTP.*/
> /* To accommodate serial byte data being shifted
> out least*/
> /* significant bit first, the table's 32 bit words
> are reflected */
> /* which flips both byte and bit MS and LS
> positions. The CRC*/
> /* is calculated MS bits first from the
> perspective of the serial*/
> /* stream. The x^32 term is implied and the x^0
> term may also*/
> /* be shown as +1. The polynomial code used is
> 0x1EDC6F41.*/
> /* Castagnoli93
>*/
> 9+x^18+x^14+x^13+ */
> /* x^11+x^10+x^9+x^8+x^6+x^0
> */
> and Martin Herrman */
> /* "Optimization of Cyclic Redundancy-Check Codes
>*/
> nd 32 Parity Bits",
> */
> nications, Vol.41, No.6, June 1993 */
> /* * * * * * * * * * * * * * * * * * * * * * * *
> * * * * * * * * */
>private static final int crc_c[] = {
>0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
>0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
>0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
>0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
>0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
>0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
>0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
>0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
>0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
>0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
>0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
>0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
>0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
>0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
>0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
>0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
>0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
>0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
>0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
>0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
>0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
>0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
>0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
>0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
>0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
>0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
>0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
>0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
>0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
>0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
>0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
>0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
>0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
>0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
>0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
>0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
>0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
>0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
>0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
>0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
>0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
>0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
>0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
>0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
>0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
>0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
>0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
>0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
>0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
>0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
>0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
>0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
>0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
>0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
>0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
>0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
>0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
>0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
>0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
>0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
>0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
>0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
>0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
>0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
> };
>
> void update(byte[] buffer, int length)
>{
>for (int i = 0; i < length ; i++)
> CRC32C(buffer);
>
> public static void main(String[] args)
>{
>byte[] rawData = {
>0x01, (byte)0xC0, 0x00, 0x00,
>0x00, 0x00, 0x00, 0x00,
>0x00, 0x00, 0x00, 0x00,
>0x00, 0x00, 0x00, 0x00,
>0x01, (byte)0xFE, 0x60, (byte)0xAC,
>0x00, 0x00, 0x00, 0x08,
>0x00, 0x00, 0x00, 0x04,
>0x00, 0x00, 0x00, 0x09,
>0x25, 0x00, 0x00, 0x00,
>0x00, 0x00, 0x00, 0x00,
>0x00, 0x00, 0x00, 0x00,
>0x00, 0x00, 0x00, 0x00
>};
>
>CRC32CDelegate delegate = new CRC32CDelegate();
>delegate.update(rawData, rawData.length);
>
> ystem.out.println(Integer.toHexString(delegate.getCRC3
> 2()));
>}
> /code]
>
> I get the same result.
This implementation does ultimately work. I accidentally munged some of
my test data for a while (which caused no end of grief). But then I went back
to the iSCSI rfc and realized that I also need to take the results from the above code, do a 1s complement on it and byte swap it. After all that, the
results match test data.
Thanks for the help!!
Eric
data on one run and then