utility.cpp

fastcopy是一个非常快速的数据拷贝软件

	if (pathArray[idx])
		free(pathArray[idx]);
	SetPath(idx, new_path);
	return	TRUE;
}

PathArray& PathArray::operator=(const PathArray& init)
{
	Init();

	pathArray = (void **)malloc(((((num = init.num) / MAX_ALLOC) + 1) * MAX_ALLOC) * sizeof(void *));

	for (int i=0; i < init.num; i++)
		SetPath(i, init.pathArray[i]);

	return	*this;
}

/*=========================================================================
	DriveMng
=========================================================================*/
DriveMng::DriveMng()
{
	memset(drvID, 0, sizeof(drvID));
	noIdCnt = 0;
}

DriveMng::~DriveMng()
{
	Init();
}

void DriveMng::Init()
{
	for (int i=0; i < MAX_DRIVE_LETTER; i++) {
		if (drvID[i].data)
			delete [] drvID[i].data;
	}
	memset(drvID, 0, sizeof(drvID));
}

BOOL DriveMng::RegisterDriveID(int idx, void *data, int len)
{
	drvID[idx].data = new BYTE [len];
	memcpy(drvID[idx].data, data, drvID[idx].len = len);
	return	TRUE;
}

BOOL DriveMng::SetDriveID(int drvLetter)
{
	TRegistry	reg(HKEY_LOCAL_MACHINE);
	BYTE		buf[1024];
	WCHAR		*wbuf = (WCHAR *)buf;
	char		reg_path[MAX_PATH * 2];
	int			size, idx = LetterToIndex(drvLetter);
	DWORD		val = 0;

// NT 宯
	if (IS_WINNT_V) {
		if (reg.OpenKey(MOUNTED_DEVICES)) {
			::sprintf(reg_path, FMT_DOSDEVICES, drvLetter);
			size = sizeof(buf);
			if (reg.GetByte(reg_path, buf, &size)) {
				if (wcsncmp(wbuf, L"\\??\\", 4) == 0 && (wbuf = wcschr(wbuf, '#')) && (wbuf = wcschr(wbuf+1, '#')) && (wbuf = wcschr(wbuf, '&'))) {
					val = wcstoul(wbuf+1, 0, 16);
				}
				else {
					val = *(DWORD *)buf;
				}
				return	RegisterDriveID(idx, &val, 4);
			}
		}
		return	RegisterDriveID(idx, &val, 1);
	}

// 95 宯
	TRegistry	dynReg(HKEY_DYN_DATA);
	char		dyn_path[MAX_PATH];
	int			no_id_cnt = 0;

	if (reg.OpenKey(ENUM_DEVICES)) {
		for (int i=0; reg.EnumKey(i, reg_path, MAX_PATH); i++) {	// SCSI, etc...
			if (reg.OpenKey(reg_path) == FALSE)
				continue;
			char *ctrl = reg_path + strlen(reg_path);
			*ctrl++ = '\\';

			for (int j=0; reg.EnumKey(j, ctrl, MAX_PATH); j++) { // Controller
				if (reg.OpenKey(ctrl) == FALSE)
					continue;
				char *dev = ctrl + strlen(ctrl);
				*dev++ = '\\';

				for (int k=0; reg.EnumKey(k, dev, MAX_PATH); k++) { // Devices...
					if (reg.OpenKey(dev) == FALSE)
						continue;

					val = 0;
					if (reg.GetStr(DRIVE_LETTERS, (char *)buf, sizeof(buf))) {
						if (*buf == 0)
							no_id_cnt++;	// format 屻丄reboot 偡傞傑偱 registry 偵枹斀塮傜偟偄
						for (int l=0; buf[l]; l++) {
							if (drvLetter == buf[l]) {
								val = 1;
								break;
							}
						}
					}
					if (val && dynReg.OpenKey(CONFIG_ENUM)) {
						for (int m=0; dynReg.EnumKey(m, dyn_path, sizeof(dyn_path)); m++) {
							if (dynReg.OpenKey(dyn_path) == FALSE)
								continue;
							if (dynReg.GetStr(HARDWARE_KEY, (char *)buf, sizeof(buf))) {
								if (strcmp(reg_path, (char *)buf) == 0) {
									return	RegisterDriveID(idx, buf, strlen((char *)buf));
								}
							}
							dynReg.CloseKey();
						}
						dynReg.CloseKey();
					}
					reg.CloseKey();
				}
				reg.CloseKey();
			}
			reg.CloseKey();
		}
	}
	if (noIdCnt == 0)
		noIdCnt = no_id_cnt;
	val = 0;
	return	RegisterDriveID(idx, &val, sizeof(val));
}

BOOL DriveMng::IsSameDrive(int drvLetter1, int drvLetter2)
{
	drvLetter1 = toupper(drvLetter1);
	drvLetter2 = toupper(drvLetter2);

	if (drvLetter1 == drvLetter2)
		return	TRUE;

	int	idx1 = LetterToIndex(drvLetter1);
	int	idx2 = LetterToIndex(drvLetter2);

	if (drvID[idx1].len == 0)
		SetDriveID(drvLetter1);

	if (drvID[idx2].len == 0)
		SetDriveID(drvLetter2);

	return	drvID[idx1].len != drvID[idx2].len ||
			memcmp(drvID[idx1].data, drvID[idx2].data, drvID[idx1].len) ||
			(IS_WINNT_V ? drvID[idx1].len == 1 : (drvID[idx1].len != 0 || noIdCnt != 1)) ? FALSE : TRUE;
}

// 儚乕僪扨埵偱偼側偔丄暥帤扨埵偱愜傝曉偡偨傔偺 EDIT Control 梡 CallBack
int CALLBACK EditWordBreakProc(LPTSTR str, int cur, int len, int action)
{
	switch (action) {
	case WB_LEFT:
		return	cur + 1;
	case WB_RIGHT:
		return	cur - 1;
	case WB_ISDELIMITER:
		return	TRUE;
	}
	return	0;
}


/*
	庤敳偒僴僢僔儏惗惉儖乕僠儞
*/
HashVal::HashVal(int _max_size)
{
	rand_data = NULL;
	if (_max_size)
		Init(_max_size);
}

HashVal::~HashVal()
{
	delete [] rand_data;
}

void HashVal::Init(int _max_size)
{
	srand(_max_size);
	rand_data = new u_int [max_size = _max_size];

	for (int i=0; i < max_size; i++) {
		rand_data[i] = ((rand() & 0xff0) << 20) | ((rand() & 0xff0) << 12) | ((rand() & 0xff0) << 4) | ((rand() & 0xff0) >> 4);
	}
}

u_int HashVal::MakeHash(void *data, int size)
{
#define MAKE_HASH_CORE(sum, data, i) ((((sum) << 7) | ((sum) >> 25)) ^ (data) ^ rand_data[(rand_data[i] ^ (data)) % max_size])
	u_int	val = 0;
	int		max_loop = size / sizeof(u_int);
	int		mod = size % sizeof(u_int), i;

	for (i=0; i < max_loop; i++) {
		u_int	tmp_val = *((u_int *)data + i);
		val = MAKE_HASH_CORE(val, tmp_val, i);
	}

	if (mod) {
		u_int	mod_val = 0;
		u_char	*p = (u_char *)data + (max_loop * sizeof(u_int) + mod);
		while (mod--) {
			mod_val <<= 8;
			mod_val |= *--p;
		}
		val = MAKE_HASH_CORE(val, mod_val, i);
	}
	return	val;
}


/*
	16恑暥帤楍 <-> 僶僀僫儕曄姺儖乕僠儞
*/
inline u_char hexchar2char(u_char ch)
{
	if (ch >= '0' && ch <= '9')
		return ch - '0';
	ch = toupper(ch);
	if (ch >= 'A' && ch <= 'Z')
		return ch - 'A' + 10;
	return 0;
}

BOOL hexstr2bin(const char *buf, BYTE *bindata, int maxlen, int *len)
{
	for (*len=0; buf[0] && buf[1] && *len < maxlen; buf+=2, (*len)++)
	{
		bindata[*len] = hexchar2char(buf[0]) << 4 | hexchar2char(buf[1]);
	}
	return	TRUE;
}

void bin2hexstr(const BYTE *bindata, int len, char *buf)
{
	static char *hexstr = "0123456789abcdef";

	for (int cnt=0; cnt < len; cnt++)
	{
		*buf++ = hexstr[bindata[cnt] >> 4];
		*buf++ = hexstr[bindata[cnt] & 0x0f];
	}
	*buf = 0;
}

/*
	僱僢僩儚乕僋僾儗乕僗傪 UNC path 偵曄姺 (src == dst 壜乯
*/

BOOL NetPlaceConvertV(void *src, void *dst)
{
	IShellLink		*shellLink;		// VC4 偵偼 IShellLink ANSI 斉偟偐掕媊偑側偄偨傔偺巄掕張抲
	IPersistFile	*persistFile;	// 乮幚嵺偼 NT宯偱偼 IShellLinkW 傪屇傃弌偟乯
	WCHAR	wSrcBuf[MAX_PATH], wDstBuf[MAX_PATH];
	WCHAR	*wSrc = IS_WINNT_V ? (WCHAR *)src : wSrcBuf;
	WCHAR	*wDst = IS_WINNT_V ? wDstBuf : (WCHAR *)dst;
	BOOL	ret = FALSE;
	DWORD	attr, attr_mask = FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_READONLY;

	if (SHGetPathFromIDListV == NULL)	// NT4.0 宯偼柍帇
		return	FALSE;

	if ((attr = GetFileAttributesV(src)) == 0xffffffff || (attr & attr_mask) != attr_mask)
		return	FALSE;	// 僨傿儗僋僩儕偐偮ronly 偱側偄傕偺偼娭學側偄

	if (SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLinkV, (void **)&shellLink))) {
		if (SUCCEEDED(shellLink->QueryInterface(IID_IPersistFile, (void **)&persistFile))) {
			if (!IS_WINNT_V)
				::MultiByteToWideChar(CP_ACP, 0, (char *)src, -1, wSrc, MAX_PATH);

			if (SUCCEEDED(persistFile->Load(wSrc, STGM_READ))) {
				if (SUCCEEDED(shellLink->GetPath((char *)wDst, MAX_PATH, NULL, SLGP_UNCPRIORITY))) {
					if (!IS_WINNT_V)
						::WideCharToMultiByte(CP_ACP, 0, wDst, -1, (char *)wDstBuf, MAX_PATH, 0, 0);
					MakePathV(dst, wDstBuf, EMPTY_STR_V);
					ret = TRUE;
				}
			}
			persistFile->Release();
		}
		shellLink->Release();
	}

	return	ret;
}

DWORD ReadReparsePoint(HANDLE hFile, void *buf, DWORD size)
{
	if (!::DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT, NULL, 0, buf, size, &size, NULL)) {
		size = 0;
	}
	return	size;
}

BOOL WriteReparsePoint(HANDLE hFile, void *buf, DWORD size)
{
	if (!::DeviceIoControl(hFile, FSCTL_SET_REPARSE_POINT, buf, size, 0, 0, &size, 0))
		return	0;

	return	TRUE;
}

BOOL IsReparseDataSame(void *d1, void *d2)
{
	REPARSE_DATA_BUFFER *r1 = (REPARSE_DATA_BUFFER *)d1;
	REPARSE_DATA_BUFFER *r2 = (REPARSE_DATA_BUFFER *)d2;

	return	r1->ReparseTag == r2->ReparseTag && r1->ReparseDataLength == r2->ReparseDataLength
		&& memcmp(&r1->GenericReparseBuffer, &r2->GenericReparseBuffer, r1->ReparseDataLength + (IsReparseTagMicrosoft(r1->ReparseTag) ? 0 : sizeof(GUID))) == 0;
}

BOOL DeleteReparsePoint(HANDLE hFile, void *buf)
{

	REPARSE_DATA_BUFFER	rdbuf;
	DWORD	size = IsReparseTagMicrosoft(((REPARSE_DATA_BUFFER *)buf)->ReparseTag) ? REPARSE_DATA_BUFFER_HEADER_SIZE : REPARSE_GUID_DATA_BUFFER_HEADER_SIZE;

	memcpy(&rdbuf, buf, size);
	rdbuf.ReparseDataLength = 0;
	return	::DeviceIoControl(hFile, FSCTL_DELETE_REPARSE_POINT, &rdbuf, size, 0, 0, &size, NULL);
}