find_same_bin_file

前言

我们的程序是基于插件的，接入一个新设备，写个插件就行。
用户以前给了很多设备协议，现在接入不同厂商设备的时候，一般都会向厂家要一份通讯协议。但是不确定的一点是，这个设备的插件写过没有？知道历史的同事不多了。想个办法，去插件工程库去查，用户给的通讯协议文档，在库中有没有2进制相同的文档如果有(可能是用户改的名字或前同事为了好记改的名字)，如果在插件库工程目录中找到2进制相同的协议文档，那这个插件就写过了，将工程拿出来重新编译一下就行。
下午花了4，5个小时，写了一个小工具，给定一个文档全路径名称，去一个目录中去查，看没有2进制相同的文件，如果找到第一个完全相同的2进制文件，就完成任务。

处理从命令行传入的中文路径名称时，有点小坑。调试了2小时。

思路

确定文件是否2进制相同，要算hash. 我在github上找了一个大神写的crc库，用其中的crc64算法。
先将要找的源文档的file_size, crc64都算出来。
遍历目录时，加一个回调，遍历到文件时，将源文件的信息(file_size, crc64) + 目标文件的全路径名称传给回调，在回调函数中算目标文件的信息(file_size, crc64), 如果和源文件相同，就找到了。

命令行用法

find_binary_same_file.cmd

@echo off
rem usage : THE_EXE modbus_device_addr modbus_cmd_byte data_addr_begin data_read_len save_to.txt cb_once_opt_max
rem argv[0] = THE_EXE
rem argv[1] = file_to_find_by_binary
rem argv[2] = dir_to_find_in
rem argv[3] = file type to find
rem e.g. to find a.pdf in dir d:\dir_b where *.pdf. command below:
rem find_same_bin_file.exe d:\my_tmp\a.pdf d:\dir_b .pdf

rem call find_same_bin_file.exe "d:\my_tmp\a.txt" "D:\my_dev\local_svn_checkout\plugin_local" .pdf

rem call find_same_bin_file.exe 'D:\my_tmp\readme.txt' 'D:\my_dev\svn_check_out\plugin_local' .txt
rem call find_same_bin_file.exe 'D:\my_tmp\readme.txt' 'D:\my_dev\svn_check_out\plugin_local .txt debug

rem call find_same_bin_file.exe 'D:\my_dev\local_svn_checkout\plugin_local\doc\T2020_0618_1048_01_user_UPS\ups_V170_20130709.pdf' 'D:\my_dev\svn_check_out\plugin_local' .pdf
call find_same_bin_file.exe 'D:\my_tmp\to_find.pdf' 'D:\my_dev\svn_check_out\plugin_local' .pdf

pause

工程实现

300行的小工程，在vs2017 vc++下完成。
最近写了几个小测试工程, 都大约300行.
看来300行就能实现一个小功能了.

// @file find_same_bin_file.cpp
// @brief find same binary file on dir

#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tchar.h>

#include ".\crc\crchash.h"

bool cb_proc_find_file(const char* psz_file, __int64 file_size, uint64_t dw_hash, const char* psz_dir, const char* psz_file_name);
typedef bool(*PFN_CB_PROC_FIND_FILE)(const char* psz_file, __int64 file_size, uint64_t dw_hash, const char* psz_dir, const char* psz_file_name);

bool find_file_on_dir_by_binary(PFN_CB_PROC_FIND_FILE pfn, const char* psz_file, __int64 file_size, uint64_t dw_hash, const char* psz_dir, const char* psz_file_type);
__int64 get_file_size(const char* psz_file);
uint64_t calc_file_hash(const char* psz_file);

int main(int argc, char** argv)
{
	int i = 0;

	char* psz_file = NULL;
	char* psz_dir = NULL;

	char sz_file[MAX_PATH * 4] = { '\0' };
	char sz_dir[MAX_PATH * 4] = { '\0' };

	bool b_find = false;
	__int64 file_size = 0;
	uint64_t dw_hash = 0;
	const char* psz_file_type_to_find = NULL;
	bool b_attach_debug_wait = true;

	do {
		setlocale(LC_ALL, ".936"); ///< 设置中文代码页, 用来显示中文字符
		printf("中文输出测试\n");

		// 通过cmd脚本传进来的中文路径参数乱码, 导致查找文件无效
		// 这和脚本的编码设置有关系
		// 用EditPlus将脚本打开，另存为ansi格式，再运行脚本，传进来的参数(中文路径)就正常了。

		// 如果传进来的要找的文件路径带空格，会导致argc错误， 所以还是将要找的文件拷贝到一个没有空格的路径，然后改一个没有空格的文件名

		if (argc < 4) {
			printf("parameter error!\n");
			printf("usage : THE_EXE modbus_device_addr modbus_cmd_byte data_addr_begin data_read_len save_to.txt cb_once_opt_max\n");
			printf("argv[0] = THE_EXE\n");
			printf("argv[1] = file_to_find_by_binary\n");
			printf("argv[2] = dir_to_find_in\n");
			printf("argv[3] = file type to find\n");
			printf("e.g. to find a.pdf in dir d:\\dir_b where *.pdf. command below:\n");
			printf("find_same_bin_file.exe d:\\my_tmp\\a.pdf d:\\dir_b .pdf");
			printf("-------- current parameter --------\n");
			printf("argc = %d\n", argc);
			for (i = 0; i < argc; i++) {
				printf("argv[%d] = %s\n", i, argv[i]);
			}

			system("pause");
			break;
		}

		printf("-------- current parameter --------\n");
		printf("argc = %d\n", argc);
		for (i = 0; i < argc; i++) {
			printf("argv[%d] = %s\n", i, argv[i]);
		}

		// 因为有带空格的路径，调用此工具命令行的时候, 文件名和路径都包了一个'\''符号，要去掉
		// 文件名
		memset(sz_file, 0, sizeof(sz_file));
		psz_file = sz_file;
		strncpy(sz_file, argv[1], sizeof(sz_file) - 1);
		if ('\'' == *psz_file) {
			psz_file++;
		}

		if ('\'' == psz_file[strlen(psz_file) - 1]) {
			psz_file[strlen(psz_file) - 1] = '\0';
		}
		
		// 路径名
		memset(sz_dir, 0, sizeof(sz_dir));
		psz_dir = sz_dir;
		strncpy(sz_dir, argv[2], sizeof(sz_dir) - 1);
		if ('\'' == *psz_dir) {
			psz_dir++;
		}

		if ('\'' == psz_dir[strlen(psz_dir) - 1]) {
			psz_dir[strlen(psz_dir) - 1] = '\0';
		}

		if (argc > 4) {
			printf("please attach to debug\n");
			do {
			} while (b_attach_debug_wait);
		}

		// 文件类型 e.g. .pdf
		psz_file_type_to_find = argv[3];

		file_size = get_file_size(psz_file);
		dw_hash = calc_file_hash(psz_file);
		printf("to find file [%s] size = [%lld], hash = [0x%I64X]\n", psz_file, file_size, dw_hash);

		b_find = find_file_on_dir_by_binary(cb_proc_find_file, psz_file, file_size, dw_hash, psz_dir, psz_file_type_to_find);
		printf("file find %s\n", b_find ? "ok" : "nothing");

	} while (0);

	return EXIT_SUCCESS;
}

bool find_file_on_dir_by_binary(PFN_CB_PROC_FIND_FILE pfn, const char* psz_file, __int64 file_size, uint64_t dw_hash, const char* psz_dir, const char* psz_file_type)
{
	bool b_rc = false;
	HANDLE hFind = INVALID_HANDLE_VALUE;
	char szDir[MAX_PATH * 4] = {'\0'};
	char szDir_sub[MAX_PATH * 4] = { '\0' };
	WIN32_FIND_DATAA ffd;
	const char* psz_postfix = "\\*.*";
	const char* psz_find_temp = NULL;

	do {
		// https://docs.microsoft.com/en-us/windows/win32/fileio/listing-the-files-in-a-directory
		memset(szDir, 0, sizeof(szDir));
		strncpy(
			szDir, 
			psz_dir,
			min((sizeof(szDir) - 1), strlen(psz_dir))
		);

		// 如果只遍历给定的目录字符串，只能找到一个文件
		// 要在目录字符串上, 附加"\\*.*"才行
		strncat(
			szDir,
			"\\",
			min(sizeof(szDir) - 1 - strlen(szDir), strlen("\\"))
		);

		strncat(
			szDir,
			"*.*",
			min (sizeof(szDir) - 1 - strlen(szDir), strlen("*.*"))
		);

		printf("find_file_on_dir_by_binary(%s)\n", szDir);
		hFind = FindFirstFileA(szDir, &ffd);
		if (INVALID_HANDLE_VALUE == hFind)
		{
			break;
		}

		do
		{
			if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
			{
				// 不遍历的子目录 : 
				// . 
				// .. 
				// .svn
				if ((0 != strcmp(".", ffd.cFileName)) && (0 != strcmp("..", ffd.cFileName)) && (0 != strcmp(".svn", ffd.cFileName))) {
					// 拷贝当前目录到副本
					memset(szDir_sub, 0, sizeof(szDir_sub));
					strncpy(
						szDir_sub,
						psz_dir,
						min((sizeof(szDir_sub) - 1), strlen(psz_dir))
					);

					strncat(
						szDir_sub,
						"\\",
						min(sizeof(szDir_sub) - 1 - strlen(szDir_sub), strlen("\\"))
					);

					// 在当前目录副本上附加子目录
					strncat(
						szDir_sub,
						ffd.cFileName,
						min(sizeof(szDir_sub) - 1 - strlen(szDir_sub), strlen(ffd.cFileName))
					);

					b_rc = find_file_on_dir_by_binary(pfn, psz_file, file_size, dw_hash, szDir_sub, psz_file_type);
					if (b_rc) {
						break;
					}
				}
			} else {
				psz_find_temp = strchr(ffd.cFileName, '.');
				if ((NULL != psz_find_temp) && (NULL != strstr(psz_find_temp, psz_file_type))) {
					if (!cb_proc_find_file(psz_file, file_size, dw_hash, psz_dir, ffd.cFileName)) {
						b_rc = true;
						break; // 已经找到了, 任务结束
					}
				}
			}
		} while (FindNextFileA(hFind, &ffd) != 0);
	} while (0);

	if (INVALID_HANDLE_VALUE != hFind) {
		FindClose(hFind);
		hFind = INVALID_HANDLE_VALUE;
	}

	return b_rc;
}

bool cb_proc_find_file(const char* psz_file, __int64 file_size, uint64_t dw_hash, const char* psz_dir, const char* psz_file_name)
{
	bool b_continue_process = true;
	char sz_buf[MAX_PATH * 4] = { '\0' };
	__int64 file_size_cur = 0;
	uint64_t dw_hash_cur = 0;

	do {
		if ((NULL == psz_dir) || (NULL == psz_file_name)) {
			break;
		}

		memset(sz_buf, 0, sizeof(sz_buf));
		strncpy(sz_buf, psz_dir, min((sizeof(sz_buf) - 1), (strlen(psz_dir))));

		strncat(sz_buf, "\\", min((sizeof(sz_buf) - 1 - strlen(sz_buf)), (strlen("\\"))));
		strncat(sz_buf, psz_file_name, min((sizeof(sz_buf) - 1 - strlen(sz_buf)), (strlen(psz_file_name))));

		printf("cb_proc_find_file(%s)\n", sz_buf);

		file_size_cur = get_file_size(sz_buf);
		dw_hash_cur = calc_file_hash(sz_buf);
		if ((file_size_cur == file_size) && (dw_hash_cur == dw_hash)) {
			printf("find binary same file [%s\\%s]\n", psz_dir, psz_file_name);
			b_continue_process = false;
		}
	} while (0);

	return b_continue_process;
}

__int64 get_file_size(const char* psz_file)
{
	__int64 file_size = -1;
	FILE* pfile = NULL;
	int i_rc = 0;

	do {
		if (NULL == psz_file) {
			break;
		}

		pfile = fopen(psz_file, "rb");
		if (NULL == pfile) {
			break;
		}

		i_rc = _fseeki64(pfile, 0, SEEK_END);
		if (0 != i_rc) {
			break;
		}

		file_size = _ftelli64(pfile);

	} while (0);

	if (NULL != pfile) {
		fclose(pfile);
		pfile = NULL;
	}

	return file_size;
}

uint64_t calc_file_hash(const char* psz_file)
{ 
	uint64_t u64_crc = 0;
	__int64 i64_file_size = 0;
	FILE* pfile = NULL;
	int i_rc = 0;
	size_t st_read_back = 0;
	unsigned char uc_buf[4096] = { '\0' };

	do {
		if (NULL == psz_file) {
			break;
		}

		i64_file_size = get_file_size(psz_file);

		pfile = fopen(psz_file, "rb");
		if (NULL == pfile) {
			break;
		}

		i_rc = _fseeki64(pfile, 0, SEEK_SET);
		if (0 != i_rc) {
			break;
		}

		do {
			st_read_back = fread(uc_buf, sizeof(char), sizeof(uc_buf), pfile);
			u64_crc = common::Hash64_ex(u64_crc, (const char*)uc_buf, st_read_back);
		} while (st_read_back > 0);
	} while (0);

	if (NULL != pfile) {
		fclose(pfile);
		pfile = NULL;
	}

	return u64_crc;
}

CRC64实现

github上的大神算crc时，是一次给定buf, size, 算出crc.
我的用法是从文件中读出一段buf, 就算一次. 如果文件没读完，再读出文件内容时，接着上次的crc继续算。
所以从大神的函数上，改了一个函数Hash64_ex, 可以接着上次的crc继续算。

uint64_t Hash64_ex(uint64_t crc, const char* cpKey, const int iKeyLen)

改过的crc封装实现

\find_same_bin_file\crc\crchash.h

/*
** Copyright (C) 2014 Wang Yaofu
** All rights reserved.
**
**Author:Wang Yaofu voipman@qq.com
**Description: The header file of class CrcHash.
*/

#ifndef _COMMON_CRC_CRCHASH_H_
#define _COMMON_CRC_CRCHASH_H_
#include <string>
#include <stdint.h>
namespace common {
    // string => 0x0000-0xffff
    uint16_t Hash16(const std::string& key);
    uint16_t Hash16(const char* cpKey, const int iKeyLen);

    // string => 0x00000000-0xffffffff
    uint32_t Hash32(const std::string& key);
    uint32_t Hash32(const char* cpKey, const int iKeyLen);

    // string => 0x0000000000000000-0xffffffffffffffff
    uint64_t Hash64(const std::string& key);
    uint64_t Hash64(const char* cpKey, const int iKeyLen); 
	uint64_t Hash64_ex(uint64_t crc, const char *s, int l);
} // namespace common
#endif  // _COMMON_CRC_CRCHASH_H_

\find_same_bin_file\crc\crchash.cpp

/*
** Copyright (C) 2014 Wang Yaofu
** All rights reserved.
**
**Author:Wang Yaofu voipman@qq.com
**Description: The source file of class CrcHash.
*/

#include "crchash.h"
#include "crc16.h"
#include "crc32.h"
#include "crc64.h"
namespace common {
    uint16_t Hash16(const std::string& key)
    {
        return crc16(key.c_str(), key.size());
    }
    uint16_t Hash16(const char* cpKey, const int iKeyLen)
    {
        return crc16(cpKey, iKeyLen);
    }

    uint32_t Hash32(const std::string& key)
    {
        return crc32(key.c_str(), key.size());
    }
    uint32_t Hash32(const char* cpKey, const int iKeyLen)
    {
        return crc32(cpKey, iKeyLen);
    }

    uint64_t Hash64(const std::string& key)
    {
        return crc64(key.c_str(), key.size());
    }
    uint64_t Hash64(const char* cpKey, const int iKeyLen)
    {
        return crc64(cpKey, iKeyLen);
    }

	uint64_t Hash64_ex(uint64_t crc, const char* cpKey, const int iKeyLen)
	{
		return crc64_ex(crc, cpKey, iKeyLen);
	}
} // namespace common

\find_same_bin_file\crc\crc64.h

#ifndef _CRC_CRC64_H
#define _CRC_CRC64_H

#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus  */

uint64_t crc64(const char *s, int l);
uint64_t crc64_ex(uint64_t crc, const char *s, int l);

#ifdef __cplusplus
}
#endif /* __cplusplus  */
#endif

\find_same_bin_file\crc\crc64.c

/* Redis uses the CRC64 variant with "Jones" coefficients and init value of 0.
 *
 * Specification of this CRC64 variant follows:
 * Name: crc-64-jones
 * Width: 64 bites
 * Poly: 0xad93d23594c935a9
 * Reflected In: True
 * Xor_In: 0xffffffffffffffff
 * Reflected_Out: True
 * Xor_Out: 0x0
 * Check("123456789"): 0xe9c6d914c4b8d9ca
 *
 * Copyright (c) 2012, Salvatore Sanfilippo <antirez at gmail dot com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *   * Neither the name of Redis nor the names of its contributors may be used
 *     to endorse or promote products derived from this software without
 *     specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE. */

#include "crc64.h"

static const uint64_t crc64_tab[256] = {
    0x0000000000000000ULL, 0x7ad870c830358979ULL,
    0xf5b0e190606b12f2ULL, 0x8f689158505e9b8bULL,
    0xc038e5739841b68fULL, 0xbae095bba8743ff6ULL,
    0x358804e3f82aa47dULL, 0x4f50742bc81f2d04ULL,
    0xab28ecb46814fe75ULL, 0xd1f09c7c5821770cULL,
    0x5e980d24087fec87ULL, 0x24407dec384a65feULL,
    0x6b1009c7f05548faULL, 0x11c8790fc060c183ULL,
    0x9ea0e857903e5a08ULL, 0xe478989fa00bd371ULL,
    0x7d08ff3b88be6f81ULL, 0x07d08ff3b88be6f8ULL,
    0x88b81eabe8d57d73ULL, 0xf2606e63d8e0f40aULL,
    0xbd301a4810ffd90eULL, 0xc7e86a8020ca5077ULL,
    0x4880fbd87094cbfcULL, 0x32588b1040a14285ULL,
    0xd620138fe0aa91f4ULL, 0xacf86347d09f188dULL,
    0x2390f21f80c18306ULL, 0x594882d7b0f40a7fULL,
    0x1618f6fc78eb277bULL, 0x6cc0863448deae02ULL,
    0xe3a8176c18803589ULL, 0x997067a428b5bcf0ULL,
    0xfa11fe77117cdf02ULL, 0x80c98ebf2149567bULL,
    0x0fa11fe77117cdf0ULL, 0x75796f2f41224489ULL,
    0x3a291b04893d698dULL, 0x40f16bccb908e0f4ULL,
    0xcf99fa94e9567b7fULL, 0xb5418a5cd963f206ULL,
    0x513912c379682177ULL, 0x2be1620b495da80eULL,
    0xa489f35319033385ULL, 0xde51839b2936bafcULL,
    0x9101f7b0e12997f8ULL, 0xebd98778d11c1e81ULL,
    0x64b116208142850aULL, 0x1e6966e8b1770c73ULL,
    0x8719014c99c2b083ULL, 0xfdc17184a9f739faULL,
    0x72a9e0dcf9a9a271ULL, 0x08719014c99c2b08ULL,
    0x4721e43f0183060cULL, 0x3df994f731b68f75ULL,
    0xb29105af61e814feULL, 0xc849756751dd9d87ULL,
    0x2c31edf8f1d64ef6ULL, 0x56e99d30c1e3c78fULL,
    0xd9810c6891bd5c04ULL, 0xa3597ca0a188d57dULL,
    0xec09088b6997f879ULL, 0x96d1784359a27100ULL,
    0x19b9e91b09fcea8bULL, 0x636199d339c963f2ULL,
    0xdf7adabd7a6e2d6fULL, 0xa5a2aa754a5ba416ULL,
    0x2aca3b2d1a053f9dULL, 0x50124be52a30b6e4ULL,
    0x1f423fcee22f9be0ULL, 0x659a4f06d21a1299ULL,
    0xeaf2de5e82448912ULL, 0x902aae96b271006bULL,
    0x74523609127ad31aULL, 0x0e8a46c1224f5a63ULL,
    0x81e2d7997211c1e8ULL, 0xfb3aa75142244891ULL,
    0xb46ad37a8a3b6595ULL, 0xceb2a3b2ba0eececULL,
    0x41da32eaea507767ULL, 0x3b024222da65fe1eULL,
    0xa2722586f2d042eeULL, 0xd8aa554ec2e5cb97ULL,
    0x57c2c41692bb501cULL, 0x2d1ab4dea28ed965ULL,
    0x624ac0f56a91f461ULL, 0x1892b03d5aa47d18ULL,
    0x97fa21650afae693ULL, 0xed2251ad3acf6feaULL,
    0x095ac9329ac4bc9bULL, 0x7382b9faaaf135e2ULL,
    0xfcea28a2faafae69ULL, 0x8632586aca9a2710ULL,
    0xc9622c4102850a14ULL, 0xb3ba5c8932b0836dULL,
    0x3cd2cdd162ee18e6ULL, 0x460abd1952db919fULL,
    0x256b24ca6b12f26dULL, 0x5fb354025b277b14ULL,
    0xd0dbc55a0b79e09fULL, 0xaa03b5923b4c69e6ULL,
    0xe553c1b9f35344e2ULL, 0x9f8bb171c366cd9bULL,
    0x10e3202993385610ULL, 0x6a3b50e1a30ddf69ULL,
    0x8e43c87e03060c18ULL, 0xf49bb8b633338561ULL,
    0x7bf329ee636d1eeaULL, 0x012b592653589793ULL,
    0x4e7b2d0d9b47ba97ULL, 0x34a35dc5ab7233eeULL,
    0xbbcbcc9dfb2ca865ULL, 0xc113bc55cb19211cULL,
    0x5863dbf1e3ac9decULL, 0x22bbab39d3991495ULL,
    0xadd33a6183c78f1eULL, 0xd70b4aa9b3f20667ULL,
    0x985b3e827bed2b63ULL, 0xe2834e4a4bd8a21aULL,
    0x6debdf121b863991ULL, 0x1733afda2bb3b0e8ULL,
    0xf34b37458bb86399ULL, 0x8993478dbb8deae0ULL,
    0x06fbd6d5ebd3716bULL, 0x7c23a61ddbe6f812ULL,
    0x3373d23613f9d516ULL, 0x49aba2fe23cc5c6fULL,
    0xc6c333a67392c7e4ULL, 0xbc1b436e43a74e9dULL,
    0x95ac9329ac4bc9b5ULL, 0xef74e3e19c7e40ccULL,
    0x601c72b9cc20db47ULL, 0x1ac40271fc15523eULL,
    0x5594765a340a7f3aULL, 0x2f4c0692043ff643ULL,
    0xa02497ca54616dc8ULL, 0xdafce7026454e4b1ULL,
    0x3e847f9dc45f37c0ULL, 0x445c0f55f46abeb9ULL,
    0xcb349e0da4342532ULL, 0xb1eceec59401ac4bULL,
    0xfebc9aee5c1e814fULL, 0x8464ea266c2b0836ULL,
    0x0b0c7b7e3c7593bdULL, 0x71d40bb60c401ac4ULL,
    0xe8a46c1224f5a634ULL, 0x927c1cda14c02f4dULL,
    0x1d148d82449eb4c6ULL, 0x67ccfd4a74ab3dbfULL,
    0x289c8961bcb410bbULL, 0x5244f9a98c8199c2ULL,
    0xdd2c68f1dcdf0249ULL, 0xa7f41839ecea8b30ULL,
    0x438c80a64ce15841ULL, 0x3954f06e7cd4d138ULL,
    0xb63c61362c8a4ab3ULL, 0xcce411fe1cbfc3caULL,
    0x83b465d5d4a0eeceULL, 0xf96c151de49567b7ULL,
    0x76048445b4cbfc3cULL, 0x0cdcf48d84fe7545ULL,
    0x6fbd6d5ebd3716b7ULL, 0x15651d968d029fceULL,
    0x9a0d8ccedd5c0445ULL, 0xe0d5fc06ed698d3cULL,
    0xaf85882d2576a038ULL, 0xd55df8e515432941ULL,
    0x5a3569bd451db2caULL, 0x20ed197575283bb3ULL,
    0xc49581ead523e8c2ULL, 0xbe4df122e51661bbULL,
    0x3125607ab548fa30ULL, 0x4bfd10b2857d7349ULL,
    0x04ad64994d625e4dULL, 0x7e7514517d57d734ULL,
    0xf11d85092d094cbfULL, 0x8bc5f5c11d3cc5c6ULL,
    0x12b5926535897936ULL, 0x686de2ad05bcf04fULL,
    0xe70573f555e26bc4ULL, 0x9ddd033d65d7e2bdULL,
    0xd28d7716adc8cfb9ULL, 0xa85507de9dfd46c0ULL,
    0x273d9686cda3dd4bULL, 0x5de5e64efd965432ULL,
    0xb99d7ed15d9d8743ULL, 0xc3450e196da80e3aULL,
    0x4c2d9f413df695b1ULL, 0x36f5ef890dc31cc8ULL,
    0x79a59ba2c5dc31ccULL, 0x037deb6af5e9b8b5ULL,
    0x8c157a32a5b7233eULL, 0xf6cd0afa9582aa47ULL,
    0x4ad64994d625e4daULL, 0x300e395ce6106da3ULL,
    0xbf66a804b64ef628ULL, 0xc5bed8cc867b7f51ULL,
    0x8aeeace74e645255ULL, 0xf036dc2f7e51db2cULL,
    0x7f5e4d772e0f40a7ULL, 0x05863dbf1e3ac9deULL,
    0xe1fea520be311aafULL, 0x9b26d5e88e0493d6ULL,
    0x144e44b0de5a085dULL, 0x6e963478ee6f8124ULL,
    0x21c640532670ac20ULL, 0x5b1e309b16452559ULL,
    0xd476a1c3461bbed2ULL, 0xaeaed10b762e37abULL,
    0x37deb6af5e9b8b5bULL, 0x4d06c6676eae0222ULL,
    0xc26e573f3ef099a9ULL, 0xb8b627f70ec510d0ULL,
    0xf7e653dcc6da3dd4ULL, 0x8d3e2314f6efb4adULL,
    0x0256b24ca6b12f26ULL, 0x788ec2849684a65fULL,
    0x9cf65a1b368f752eULL, 0xe62e2ad306bafc57ULL,
    0x6946bb8b56e467dcULL, 0x139ecb4366d1eea5ULL,
    0x5ccebf68aecec3a1ULL, 0x2616cfa09efb4ad8ULL,
    0xa97e5ef8cea5d153ULL, 0xd3a62e30fe90582aULL,
    0xb0c7b7e3c7593bd8ULL, 0xca1fc72bf76cb2a1ULL,
    0x45775673a732292aULL, 0x3faf26bb9707a053ULL,
    0x70ff52905f188d57ULL, 0x0a2722586f2d042eULL,
    0x854fb3003f739fa5ULL, 0xff97c3c80f4616dcULL,
    0x1bef5b57af4dc5adULL, 0x61372b9f9f784cd4ULL,
    0xee5fbac7cf26d75fULL, 0x9487ca0fff135e26ULL,
    0xdbd7be24370c7322ULL, 0xa10fceec0739fa5bULL,
    0x2e675fb4576761d0ULL, 0x54bf2f7c6752e8a9ULL,
    0xcdcf48d84fe75459ULL, 0xb71738107fd2dd20ULL,
    0x387fa9482f8c46abULL, 0x42a7d9801fb9cfd2ULL,
    0x0df7adabd7a6e2d6ULL, 0x772fdd63e7936bafULL,
    0xf8474c3bb7cdf024ULL, 0x829f3cf387f8795dULL,
    0x66e7a46c27f3aa2cULL, 0x1c3fd4a417c62355ULL,
    0x935745fc4798b8deULL, 0xe98f353477ad31a7ULL,
    0xa6df411fbfb21ca3ULL, 0xdc0731d78f8795daULL,
    0x536fa08fdfd90e51ULL, 0x29b7d047efec8728ULL,
};

uint64_t crc64(const char *s, int l) {
    int j = 0;
    uint64_t crc = 0;

    for (j = 0; j < l; j++) {
        uint8_t byte = s[j];
        crc = crc64_tab[(uint8_t)crc ^ byte] ^ (crc >> 8);
    }
    return crc;
}

uint64_t crc64_ex(uint64_t crc, const char *s, int l) {
	int j = 0;

	for (j = 0; j < l; j++) {
		uint8_t byte = s[j];
		crc = crc64_tab[(uint8_t)crc ^ byte] ^ (crc >> 8);
	}

	return crc;
}

/* Test main */
#ifdef TEST_MAIN
#include <stdio.h>
int main(void) {
    printf("e9c6d914c4b8d9ca == %016llx\n",
        (unsigned long long) crc64("123456789",9));
    return 0;
}
#endif

\find_same_bin_file\crc\crc32.h

#ifndef _CRC_CRC32_H
#define _CRC_CRC32_H

#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus  */

uint32_t crc32(const char* s, int len);

#ifdef __cplusplus
}
#endif /* __cplusplus  */
#endif

\find_same_bin_file\crc\crc32.c

/*
** Copyright (C) 2014 Wang Yaofu
** All rights reserved.
**
**Author:Wang Yaofu voipman@qq.com
**Description: The source file of class crc32.
*/
#include <stdlib.h>
#include "crc32.h"
static uint32_t crc32_tab[] =
{
    0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
    0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
    0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
    0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
    0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
    0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
    0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
    0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
    0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
    0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
    0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
    0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
    0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
    0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
    0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
    0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
    0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
    0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
    0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
    0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
    0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
    0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
    0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
    0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
    0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
    0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
    0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
    0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
    0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
    0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
    0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
    0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
    0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
    0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
    0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
    0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
    0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
    0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
    0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
    0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
    0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
    0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
    0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
    0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
    0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
    0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
    0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
    0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
    0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
    0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
    0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
    0x2d02ef8dL
};

/* crc32 hash */
uint32_t crc32(const char* s, int len)
{
    int i;
    uint32_t crc32val = 0;
    crc32val ^= 0xFFFFFFFF;

    for (i = 0;  i < len;  i++) {
        crc32val = crc32_tab[(crc32val ^ s[i]) & 0xFF] ^ ((crc32val >> 8) & 0x00FFFFFF);
    }

    return labs(crc32val ^ 0xFFFFFFFF);
}

\find_same_bin_file\crc\crc16.h

#ifndef _CRC_CRC16_H
#define _CRC_CRC16_H

#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus  */

uint16_t crc16(const char *buf, int len);

#ifdef __cplusplus
}
#endif /* __cplusplus  */
#endif

\find_same_bin_file\crc\crc16.c

#include "crc16.h"

/*
 * Copyright 2001-2010 Georges Menie (www.menie.org)
 * Copyright 2010-2012 Salvatore Sanfilippo (adapted to Redis coding style)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the University of California, Berkeley nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* CRC16 implementation according to CCITT standards.
 *
 * Note by @antirez: this is actually the XMODEM CRC 16 algorithm, using the
 * following parameters:
 *
 * Name                       : "XMODEM", also known as "ZMODEM", "CRC-16/ACORN"
 * Width                      : 16 bit
 * Poly                       : 1021 (That is actually x^16 + x^12 + x^5 + 1)
 * Initialization             : 0000
 * Reflect Input byte         : False
 * Reflect Output CRC         : False
 * Xor constant to output CRC : 0000
 * Output for "123456789"     : 31C3
 */

static const uint16_t crc16tab[256]= {
    0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
    0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
    0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
    0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
    0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
    0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
    0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
    0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
    0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
    0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
    0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
    0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
    0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
    0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
    0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
    0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
    0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
    0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
    0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
    0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
    0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
    0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
    0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
    0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
    0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
    0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
    0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
    0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
    0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
    0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
    0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
    0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
};

uint16_t crc16(const char *buf, int len) {
    int counter;
    uint16_t crc = 0;
    for (counter = 0; counter < len; counter++)
            crc = (crc<<8) ^ crc16tab[((crc>>8) ^ *buf++)&0x00FF];
    return crc;
}

总结

简单的小工程,等用到时，先开一个空工程，花10分钟，从笔记上复制出来，贴到工程中，重新编译一下，一个测试工具就出来了。