开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
CRC32.c
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：14k
源码类别：

模拟服务器

开发平台：

C/C++

CRC32.c：源码内容
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  FileName    :   CRC32.C
  4. //  Creater     :   Freeway Chen
  5. //  Date        :   2000-6-15 18:25:43
  6. //  Comment     :   Get source code from Zlib Project
  7. //
  8. //////////////////////////////////////////////////////////////////////////////////////
  10. /* crc32.c -- compute the CRC-32 of a data stream
  11.  * Copyright (C) 1995-1998 Mark Adler
  12.  * For conditions of distribution and use, see copyright notice in zlib.h 
  13.  */
  15. #ifdef _STANDALONE
  16. typedef unsigned long CRC_UINT32;
  17. typedef unsigned char  CRC_BYTE;
  18. #else
  19. typedef unsigned __int32 CRC_UINT32;
  20. typedef unsigned __int8  CRC_BYTE;
  21. #endif
  23. #ifdef DYNAMIC_CRC_TABLE
  25. static int CRCTableEmptyFlag = 1;
  26. static CRC_UINT32 CRC_Table[256];
  27. static void MakeCRCTable(void);
  29. /*
  30.   Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
  31.   x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
  33.   Polynomials over GF(2) are represented in binary, one bit per coefficient,
  34.   with the lowest powers in the most significant bit.  Then adding polynomials
  35.   is just exclusive-or, and multiplying a polynomial by x is a right shift by
  36.   one.  If we call the above polynomial p, and represent a byte as the
  37.   polynomial q, also with the lowest power in the most significant bit (so the
  38.   byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
  39.   where a mod b means the remainder after dividing a by b.
  41.   This calculation is done using the shift-register method of multiplying and
  42.   taking the remainder.  The register is initialized to zero, and for each
  43.   incoming bit, x^32 is added mod p to the register if the bit is a one (where
  44.   x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
  45.   x (which is shifting right by one and adding x^32 mod p if the bit shifted
  46.   out is a one).  We start with the highest power (least significant bit) of
  47.   q and repeat for all eight bits of q.
  49.   The table is simply the CRC of all possible eight bit values.  This is all
  50.   the information needed to generate CRC's on data a byte at a time for all
  51.   combinations of CRC register values and incoming bytes.
  52. */
  53. static void MakeCRCTable()
  54. {
  55.   CRC_UINT32 CRC;
  56.   CRC_UINT32 n, k;
  57.   CRC_UINT32 poly;            /* polynomial exclusive-or pattern */
  58.   /* terms of polynomial defining this crc (except x^32): */
  59.   static const CRC_BYTE p[] = {0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26};
  61.   /* make exclusive-or pattern from polynomial (0xedb88320L) */
  62.   poly = 0L;
  63.   for (n = 0; n < sizeof(p) / sizeof(CRC_BYTE); n++)
  64.     poly |= 1L << (31 - p[n]);
  65.  
  66.   for (n = 0; n < 256; n++)
  67.   {
  68.     CRC = n;
  69.     for (k = 0; k < 8; k++)
  70.     {
  71.         if (CRC & 1)
  72.             CRC = poly ^ (CRC >> 1);
  73.         else
  74.             CRC = CRC >> 1;
  75.     }
  76.     CRC_Table[n] = CRC;
  77.   }
  78.   CRCTableEmptyFlag = 0;
  79. }
  80. #else
  82. // ========================================================================
  83. // Table of CRC-32's of all single-byte values (made by make_crc_table)
  84. //
  86. static const CRC_UINT32 CRC_Table[256] = {
  87.   0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  88.   0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  89.   0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  90.   0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  91.   0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  92.   0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  93.   0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  94.   0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  95.   0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
  96.   0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
  97.   0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
  98.   0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
  99.   0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
  100.   0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
  101.   0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
  102.   0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
  103.   0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
  104.   0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
  105.   0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
  106.   0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
  107.   0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
  108.   0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
  109.   0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
  110.   0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
  111.   0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
  112.   0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
  113.   0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
  114.   0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
  115.   0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
  116.   0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
  117.   0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
  118.   0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
  119.   0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
  120.   0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
  121.   0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
  122.   0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
  123.   0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
  124.   0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
  125.   0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
  126.   0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
  127.   0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
  128.   0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
  129.   0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
  130.   0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
  131.   0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
  132.   0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
  133.   0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
  134.   0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
  135.   0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
  136.   0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
  137.   0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
  138.   0x2d02ef8dL
  139. };
  140. #endif  // DYNAMIC_CRC_TABLE
  142. // =========================================================================
  143. // This function can be used by asm versions of crc32()
  144. //
  145. const CRC_UINT32 * GetCRCTable()
  146. {
  147. #ifdef DYNAMIC_CRC_TABLE
  148.   if (CRCTableEmptyFlag) 
  149.       MakeCRCTable();
  150. #endif
  152.   return (const CRC_UINT32 *)CRC_Table;
  153. }
  157. // Use internal CRC32 function
  158. // =========================================================================
  159. #define DO1BYTE(pBuf) CRC = CRC_Table[(CRC ^ (*pBuf++)) & 0xff] ^ (CRC >> 8);
  160. //#define DO2(pBuf)  DO1(pBuf); DO1(pBuf);
  161. //#define DO4(pBuf)  DO2(pBuf); DO2(pBuf);
  162. //#define DO8(pBuf)  DO4(pBuf); DO4(pBuf);
  163. // =========================================================================
  165. unsigned CRC32_C(unsigned CRC, const void *pvBuf, int nLen)
  166. //unsigned CRC32(unsigned CRC, const void *pvBuf, int nLen)
  167. {
  168.     const CRC_BYTE *pBuf = (const CRC_BYTE *)pvBuf;
  170.     if (pvBuf == (void *)0)
  171.         return 0L;
  173.     #ifdef DYNAMIC_CRC_TABLE
  174.     if (CRCTableEmptyFlag)
  175.         MakeCRCTable();
  176.     #endif  // DYNAMIC_CRC_TABLE
  178.     CRC = CRC ^ 0xffffffffL;    // equal CRC = ~CRC
  179.     while (nLen >= 8)
  180.     {
  181.         // It's easy to debug
  182.         DO1BYTE(pBuf);          // 0
  183.         DO1BYTE(pBuf);          // 1
  184.         DO1BYTE(pBuf);          // 2
  185.         DO1BYTE(pBuf);          // 3
  186.         DO1BYTE(pBuf);          // 4
  187.         DO1BYTE(pBuf);          // 5
  188.         DO1BYTE(pBuf);          // 6
  189.         DO1BYTE(pBuf);          // 7
  191.         nLen -= 8;
  192.     }
  193.     if (nLen)
  194.     {
  195.         do {
  196.             DO1BYTE(pBuf);
  197.         } while (--nLen);
  198.     }
  199.     return (CRC ^ 0xffffffffL);   // equal return ~CRC
  200. }
  202. // ============================================================================
  203. //
  204. // ASM Part in Visual C++
  205. //
  206. // ============================================================================
  208. //#define DO1BYTE(pBuf) CRC = CRC_Table[(CRC ^ (*pBuf++)) & 0xff] ^ (CRC >> 8);
  209. #define DO1BYTEASM() 
  210.     __asm{ mov bl, [esi] } 
  211.     __asm{ inc esi } 
  212.     __asm{ xor ebx, eax } 
  213.     __asm{ shr eax, 8 } 
  214.     __asm{ and ebx, 0xff } 
  215.     __asm{ xor eax, CRC_Table[ebx * 4] }
  218. //unsigned CRC32_ASM(unsigned CRC, const void *pvBuf, int nLen)
  219. unsigned CRC32(unsigned CRC, const void *pvBuf, int nLen)
  220. {
  221. #ifndef WIN32
  222. return CRC32_C(CRC, pvBuf, nLen);
  223. #else
  224.     unsigned RetCode = 0;
  226.     if (!pvBuf)
  227.         return RetCode;
  229.     __asm mov esi, [pvBuf]
  230.     __asm mov ecx, [nLen]
  231.     __asm mov eax, [CRC]
  232.     __asm shr ecx, 3
  233.     __asm xor eax, 0xffffffff
  235.     __asm test ecx, ecx
  236.     __asm jz CRC_Last7Bytes
  237.     
  238.     __asm push ebp
  239.     __asm mov ebp, ecx
  241.     __asm xor edx, edx
  242.     __asm xor ecx, ecx
  244.     __asm align 4
  246. CRC_Loop1:
  247.     // eax = CRC
  248.     // edx first TableIndex
  249.     // ecx second TableIndex
  251.     // Process 4 bytes
  252.     __asm mov ebx, [esi]
  253.     __asm add esi, 4
  254.     
  255.     __asm mov dl, bl
  256.     __asm mov cl, bh
  257.     __asm xor dl, al
  258.     __asm shr eax, 8
  259.     __asm mov edi, CRC_Table[edx * 4]
  260.     __asm shr ebx, 16
  261.     __asm xor eax, edi
  263.     __asm xor cl, al
  264.     __asm shr eax, 8
  265.     __asm mov edi, CRC_Table[ecx * 4]
  266.     __asm mov dl, bl
  267.     __asm xor eax, edi
  269.     __asm xor dl, al
  270.     __asm shr eax, 8
  271.     __asm mov edi, CRC_Table[edx * 4] 
  272.     __asm mov cl, bh
  273.     __asm xor eax, edi
  275.     __asm mov ebx, [esi]
  276.     __asm xor cl, al
  277.     __asm shr eax, 8
  278.     __asm mov edi, CRC_Table[ecx * 4]
  279.     __asm add esi, 4
  280.     __asm xor eax, edi
  281.     
  282.     __asm mov dl, bl
  283.     __asm mov cl, bh
  284.     __asm xor dl, al
  285.     __asm shr eax, 8
  286.     __asm mov edi, CRC_Table[edx * 4]
  287.     __asm shr ebx, 16
  288.     __asm xor eax, edi
  290.     __asm xor cl, al
  291.     __asm shr eax, 8
  292.     __asm mov edi, CRC_Table[ecx * 4]
  293.     __asm mov dl, bl
  294.     __asm xor eax, edi
  296.     __asm xor dl, al
  297.     __asm shr eax, 8
  298.     __asm mov edi, CRC_Table[edx * 4] 
  299.     __asm mov cl, bh
  300.     __asm xor eax, edi
  302.     __asm xor cl, al
  303.     __asm shr eax, 8
  304.     __asm xor eax, CRC_Table[ecx * 4]
  306.     __asm dec ebp
  307.     __asm jnz CRC_Loop1
  309.     __asm pop ebp
  311. CRC_Last7Bytes:
  313.     __asm mov ecx, [nLen]
  315.     __asm xor edx, edx
  316.     __asm and ecx, 0x7
  317.     __asm jz CRC_Exit
  319. CRC_Loop2:
  321.     __asm mov dl, [esi]
  322.     __asm inc esi
  323.     __asm xor dl, al
  324.     __asm shr eax, 8
  325.     __asm xor eax, CRC_Table[edx * 4]
  327.     __asm dec ecx
  328.     __asm jnz CRC_Loop2
  330. CRC_Exit:
  332.     __asm xor eax, 0xffffffff
  333.     __asm mov [RetCode], eax
  335.     return RetCode;
  336. #endif
  337. }
  339. /*
  340. unsigned CRC32(unsigned CRC, const void *pvBuf, int nLen)
  341. {
  342.     unsigned RetCode = 0;
  344.     if (!pvBuf)
  345.         return RetCode;
  347.     __asm mov esi, [pvBuf]
  348.     __asm mov ecx, [nLen]
  349.     __asm mov eax, [CRC]
  350.     __asm shr ecx, 3
  351.     __asm xor eax, 0xffffffff
  353.     __asm test ecx, ecx
  354.     __asm jz CRC_Last7Bytes
  356. CRC_Loop1:
  357.     __asm xor edx, edx
  359.     // Process 4 bytes
  360.     __asm mov ebx, [esi]
  361.     __asm add esi, 4
  362.     
  363.     __asm mov dl, bl
  364.     __asm shr ebx, 8
  366.     __asm xor dl, al
  367.     __asm shr eax, 8
  368.     __asm mov edi, CRC_Table[edx * 4]
  369.     
  370.     __asm mov dl, bl
  371.     __asm xor eax, edi
  372.     
  373.     __asm shr ebx, 8
  374.     __asm xor dl, al
  375.     __asm shr eax, 8
  376.     __asm mov edi, CRC_Table[edx * 4]
  378.     __asm mov dl, bl
  379.     __asm xor eax, edi
  380.     
  381.     __asm shr ebx, 8
  382.     __asm xor dl, al
  383.     __asm shr eax, 8
  384.     __asm mov edi, CRC_Table[edx * 4]
  386.     __asm mov dl, bl
  387.     __asm xor eax, edi
  388.     
  389.     __asm xor dl, al
  390.     __asm shr eax, 8
  391.     __asm xor eax, CRC_Table[edx * 4]
  392.     
  394.     // Process 4 bytes
  395.     __asm mov ebx, [esi]
  396.     __asm add esi, 4
  397.     
  398.     __asm mov dl, bl
  399.     __asm shr ebx, 8
  401.     __asm xor dl, al
  402.     __asm shr eax, 8
  403.     __asm mov edi, CRC_Table[edx * 4]
  404.     
  405.     __asm mov dl, bl
  406.     __asm xor eax, edi
  407.     
  408.     __asm shr ebx, 8
  409.     __asm xor dl, al
  410.     __asm shr eax, 8
  411.     __asm mov edi, CRC_Table[edx * 4]
  413.     __asm mov dl, bl
  414.     __asm xor eax, edi
  415.     
  416.     __asm shr ebx, 8
  417.     __asm xor dl, al
  418.     __asm shr eax, 8
  419.     __asm mov edi, CRC_Table[edx * 4]
  421.     __asm mov dl, bl
  422.     __asm xor eax, edi
  423.     
  424.     __asm xor dl, al
  425.     __asm shr eax, 8
  426.     __asm xor eax, CRC_Table[edx * 4]
  428.     __asm dec ecx
  429.     __asm jnz CRC_Loop1
  431. CRC_Last7Bytes:
  433.     __asm mov ecx, [nLen]
  434.     __asm xor edx, edx
  435.     
  436.     __asm test ecx, 0x4
  437.     __asm jz CRC_Last3Bytes
  440.     // Process 4 bytes
  441.     __asm mov ebx, [esi]
  442.     __asm add esi, 4
  443.     
  444.     __asm mov dl, bl
  445.     __asm shr ebx, 8
  447.     __asm xor dl, al
  448.     __asm shr eax, 8
  449.     __asm mov edi, CRC_Table[edx * 4]
  450.     
  451.     __asm mov dl, bl
  452.     __asm xor eax, edi
  453.     
  454.     __asm shr ebx, 8
  455.     __asm xor dl, al
  456.     __asm shr eax, 8
  457.     __asm mov edi, CRC_Table[edx * 4]
  459.     __asm mov dl, bl
  460.     __asm xor eax, edi
  461.     
  462.     __asm shr ebx, 8
  463.     __asm xor dl, al
  464.     __asm shr eax, 8
  465.     __asm mov edi, CRC_Table[edx * 4]
  467.     __asm mov dl, bl
  468.     __asm xor eax, edi
  469.     
  470.     __asm xor dl, al
  471.     __asm shr eax, 8
  472.     __asm xor eax, CRC_Table[edx * 4]
  473.     
  474. CRC_Last3Bytes:
  476.     __asm xor edx, edx
  477.     __asm and ecx, 0x3
  478.     __asm jz CRC_Exit
  480. CRC_Loop2:
  482.     __asm mov dl, [esi]
  483.     __asm inc esi
  484.     __asm xor dl, al
  485.     __asm shr eax, 8
  486.     __asm xor eax, CRC_Table[edx * 4]
  488.     __asm dec ecx
  489.     __asm jnz CRC_Loop2
  491. CRC_Exit:
  493.     __asm xor eax, 0xffffffff
  494.     __asm mov [RetCode], eax
  496.     return RetCode;
  497. }
  498. */