regmodify.cpp

wince 注册表的设置和清除程序, 在调试软件时, 编写一个注册表文件,运行此程序便可.

//#include"ghAw.h"
#include <STDIO.H>
#include <windows.h>
#include "stdio.h"
#include "stdlib.h"
#include "string.h"


#define FileInName		"regFile.ini"


#define ERROR_FLAG					0
#define NONETYPE_FLAG				1
#define HEADTYPE_FLAG				2
#define DWORDTYPE_FLAG				3
#define STRINGTYPE_FLAG				4
#define BINARYTYPE_FLAG				5

typedef struct _HeadType
{
	DWORD Head;   //1--HKEY_CLASSES_ROOT, 2--HKEY_CURRENT_USER, 3--HKEY_LOCAL_MACHINE, 4--HKEY_USERS 
	              //5--Delete HKEY_CLASSES_ROOT, 6--Delete HKEY_CURRENT_USER, 7--Delete HKEY_LOCAL_MACHINE, 8--Delete HKEY_USERS 
	TCHAR SubString[128];
}HEADTYPE;

typedef struct _DWordType
{
	TCHAR ClassName[128];
	DWORD data;
}DWORDTYPE;

typedef struct _StringType
{
	TCHAR ClassName[128];
	TCHAR Value[1024];
}STRINGTYPE;

typedef struct _BinaryType
{
	TCHAR ClassName[128];
	BYTE Binary[256];
	DWORD Len;
}BINARYTYPE;

///////////
HEADTYPE headTypeX;
DWORDTYPE dwordTypeX;
STRINGTYPE stringTypeX;
BINARYTYPE binaryTypeX;

void SetToRegistry(BYTE *data, DWORD size, DWORD type,HKEY key, LPCTSTR lpszRegKey, LPCTSTR lpszRegValue)
{
    HKEY    hKey;

	if(ERROR_SUCCESS == RegOpenKeyEx(key, lpszRegKey, 0, 0, &hKey))
	{
		RegSetValueEx(hKey, lpszRegValue, 0, type, (LPBYTE)data, size);
		RegCloseKey(hKey);
	}
}

int readOneLine(unsigned char *buffer, long int buflen, long int begin, long int *end)
{
//	if (*end > buflen)
//		return FALSE;
	
	long int i = begin;
	while(i < buflen)
	{
		if ((buffer[i] == 0x0d) && (buffer[i+1] == 0x0a))
		{
			i += 2;
			break;
		}
		else
			i++;
	}

	if ((i >= buflen) && (buffer[i - 1] != 0x0a))
	{
		*end = buflen;
		return TRUE;
	}
	else
		*end	= i;

	return TRUE;
}

BOOL stringComp(unsigned char *data, const char *constData)
{
	int len = strlen(constData);
	int i = 0;
	unsigned char c1,c2;
	while (i < len)
	{
		if (data[i] != constData[i])
		{
			if ((data[i] >= 'a') && (data[i] <= 'z'))
				c1 = data[i] - 'a';
			else if ((data[i] >= 'A') && (data[i] <= 'Z'))
				c1 = data[i] - 'A';
			else 
				c1 = 0xff;
				
			if ((constData[i] >= 'a') && (constData[i] <= 'z'))
				c2 = constData[i] - 'a';
			else if ((constData[i] >= 'A') && (constData[i] <= 'Z'))
				c2 = constData[i] - 'A';
			else
				c2 = 0xfe;
			if (c1 != c2)
				return FALSE;	
		}
		i++;
	}
	return TRUE;
}

BOOL isRemark(unsigned char *buffer, DWORD buflen)
{
	DWORD i = 0;
	while ((i < buflen) && ((buffer[i] == 0x20) || (buffer[i] == 0x09)))
		i ++;
	if ((buffer[i] == 0x0d) && (buffer[i + 1] == 0x0a))
		return TRUE;
	else if (buffer[i] == ';')
		return TRUE;
	else
		return FALSE;
}

BOOL isHead(unsigned char *buffer, DWORD buflen, void **head)
{
	DWORD i = 0;

	while ((i < buflen) && ((buffer[i] == 0x20) || (buffer[i] == 0x09)))
		i ++;

	if ((buffer[i] == 0x0d) && (buffer[i + 1] == 0x0a))
		return FALSE;
		
	if (buffer[i] == '[')
	{
		DWORD start = i + 1;
		while ((i < buflen) && (buffer[i] != ']'))
			i ++;
		if (buffer[i] == ']')
		{
			int tag = 0;
			DWORD len = 0;
			if (stringComp(&buffer[start], "HKEY_CLASSES_ROOT\\"))
			{
				tag = 1;
				len = 18;
			}
			else if (stringComp(&buffer[start], "-HKEY_CLASSES_ROOT\\"))
			{
				tag = 5;
				len = 19;
			}
			else if (stringComp(&buffer[start], "HKEY_CURRENT_USER\\"))
			{
				tag = 2;
				len = 18;
			}
			else if (stringComp(&buffer[start], "-HKEY_CURRENT_USER\\"))
			{
				tag = 6;
				len = 19;
			}
			else if (stringComp(&buffer[start], "HKEY_LOCAL_MACHINE\\"))
			{
				tag = 3;
				len = 19;
			}
			else if (stringComp(&buffer[start], "-HKEY_LOCAL_MACHINE\\"))
			{
				tag = 7;
				len = 20;
			}
			else if (stringComp(&buffer[start], "HKEY_USERS\\"))
			{
				tag = 4;
				len = 11;
			}
			else if (stringComp(&buffer[start], "-HKEY_USERS\\"))
			{
				tag = 8;
				len = 12;
			}
			else
				return FALSE;	
				
			HEADTYPE *pHead = &headTypeX;
			if (pHead == NULL)
				return FALSE;

			memset(pHead,0,sizeof(HEADTYPE));
			*head = (void *)pHead;
			pHead->Head = tag;
				
			DWORD j = start+len;
			len = i - j;
			for(i = 0; i < len; i ++)
			{
				pHead->SubString[i] = buffer[j+i];

			}
			return TRUE;
		}
		else
			return FALSE;
	}
	else
		return FALSE;
}


BOOL getClassName(unsigned char *buffer, DWORD buflen, DWORD *namelen, TCHAR *ClassName)
{
	DWORD i = 0;

	while ((i < buflen) && ((buffer[i] == 0x20) || (buffer[i] == 0x09)))
		i ++;

	if (buffer[i] != '\"')
	{
		if ((buffer[i] == '@') && (buffer[i+1] == '='))
		{
			*namelen = i + 1;
			ClassName[0] = 0;
			return TRUE;
		}
		return FALSE;
	}
	
	i++;
	DWORD start = i;
	
	while ((i < buflen) && (buffer[i] != '\"'))
		i ++;

	if (buffer[i] != '\"')
		return FALSE;

	DWORD len = i - start;
	*namelen = i + 1;
	
	for(i = 0; i < len; i ++)
		ClassName[i] = buffer[start + i];

	ClassName[i] = 0;
	
	return TRUE;
}


BOOL GetDWordData(unsigned char *buffer, DWORD buflen, DWORD *value)
{
	DWORD i = 0;
	
	while ((i < buflen) && ((buffer[i] == 0x20) || (buffer[i] == 0x09)))
		i ++;
		
	DWORD data = 0;
	while (i < buflen)
	{
		if ((buffer[i] >= 'a') && (buffer[i] <= 'z'))
			data = data * 16 + buffer[i] - 'a' + 10;
		else if ((buffer[i] >= 'A') && (buffer[i] <= 'Z'))
			data = data * 16 + buffer[i] - 'A' + 10;
		else if ((buffer[i] >= '0') && (buffer[i] <= '9'))
			data = data * 16 + buffer[i] - '0';
		else if ((buffer[i] == 0x20) || (buffer[i] == 0x09) || (buffer[i] == ';') || (buffer[i] == 0x0d))
			break;
		else
			return FALSE;
		i++;
	}

	*value = data;
	return TRUE;
}

BOOL GetBinaryData(unsigned char *buffer, DWORD buflen, BYTE *value, DWORD *len)
{
	DWORD i = 0;

	*len = 0;
	while (i < buflen)
	{	
		BYTE data = 0;
		
		while ((i < buflen) && ((buffer[i] == 0x20) || (buffer[i] == 0x09)))
			i ++;
		
		while (i < buflen)
		{
			if ((buffer[i] >= 'a') && (buffer[i] <= 'z'))
				data = data * 16 + buffer[i] - 'a' + 10;
			else if ((buffer[i] >= 'A') && (buffer[i] <= 'Z'))
				data = data * 16 + buffer[i] - 'A' + 10;
			else if ((buffer[i] >= '0') && (buffer[i] <= '9'))
				data = data * 16 + buffer[i] - '0';
			else if ((buffer[i] == 0x20) || (buffer[i] == 0x09) || (buffer[i] == ',') || (buffer[i] == ';') || (buffer[i] == 0x0d))
				break;
			else
				return FALSE;
			i++;
		}
		
		value[*len] = data;
		(*len) ++;
		
		while ((i < buflen) && (buffer[i] != ','))
			i ++;
		if (buffer[i] != ',')
		{
			return TRUE;
		}
		i++;
	}
	
	return TRUE;
}

BOOL GetDataFromRegFile(TCHAR *regFileName, unsigned char **data, DWORD *dataLen)
{
	WIN32_FIND_DATA fd;
	HANDLE hFind;
	
	hFind = FindFirstFile(regFileName, &fd);

	if(hFind == INVALID_HANDLE_VALUE)
		return FALSE;
	FindClose(hFind);

	DWORD fileLen = fd.nFileSizeLow;
	if (fileLen == 0)
		return FALSE;
	
	FILE *fp = _wfopen(regFileName, _T("rb"));
	if (fp == NULL)
		return FALSE;

	fileLen = (fileLen >> 2) * 4 + 8;
	*data = new unsigned char[fileLen];
	if ((*data) == NULL)
	{
		fclose(fp);
		return FALSE;
	}
	memset(*data, 0, fileLen);
	*dataLen = fread(*data , 1, fileLen, fp);
	(*data)[*dataLen] = 0x0d;
	(*data)[*dataLen+1] = 0x0a;
	*dataLen += 2;

	fclose(fp);
	
	if (*dataLen == 0)
	{
		delete *data;
		*data = NULL;
		return FALSE;
	}
	return TRUE;
}

DWORD GetTypeItem(unsigned char *data, DWORD bufferLen, void **typeValue, DWORD *len)
{
	DWORD begin = 0;
	if (readOneLine(data, bufferLen, begin, (long *)len) == TRUE)
	{
		if (isRemark(data, *len))
			return NONETYPE_FLAG;
		else if (isHead(data, *len, typeValue))
			return HEADTYPE_FLAG;
		else 
		{
			TCHAR ClassName[128];
			DWORD namelen;
			if (getClassName(data, *len, &namelen, ClassName))
			{
				if (data[namelen] == '=')
				{
					namelen ++;
					if (data[namelen] == '\"')
					{
						namelen ++;
						DWORD i = namelen;
						while ((i < *len) && (data[i] != '\"'))
						{
							if (data[i] == '\\')
								i ++;
							i ++;
						}
						if (data[i] == '\"')
						{
							STRINGTYPE *pString = &stringTypeX;
							if (pString == NULL)
								return ERROR_FLAG;

							wcscpy(pString->ClassName,ClassName);
							DWORD len = i - namelen;
							DWORD j = 0;
							for(i = 0; i < len; i ++)
							{
								if (data[namelen + i] == '\\')
								{
									i ++;
									if (data[namelen + i] == 'r')
										pString->Value[j] = 0x0d;
									else if (data[namelen + i] == 'n')
										pString->Value[j] = 0x0a;
									else 
										pString->Value[j] = data[namelen + i];
								}
								else
									pString->Value[j] = data[namelen + i];
								j ++;
							}
							pString->Value[j] = 0;
							
							*typeValue = (void *)pString;							
							return STRINGTYPE_FLAG;				
						}
					}
					else if (stringComp(&data[namelen], "dword:"))
					{
						namelen += 6;
						DWORD value;
						if (GetDWordData(&data[namelen], *len - namelen, &value))
						{
							DWORDTYPE *pDword = &dwordTypeX;
							if (pDword == NULL)
								return ERROR_FLAG;

							wcscpy(pDword->ClassName,ClassName);
							pDword->data = value;
							
							*typeValue = (void *)pDword;	
							return DWORDTYPE_FLAG;
						}
					}
					else if (stringComp(&data[namelen], "hex:"))
					{
						namelen += 4;
						BYTE Binary[256];
						DWORD lenx;

						if (GetBinaryData(&data[namelen], *len - namelen, Binary, &lenx))
						{
							if (lenx > 0)
							{
								BINARYTYPE *pBinary = &binaryTypeX;
								if (pBinary == NULL)
									return ERROR_FLAG;
							
								wcscpy(pBinary->ClassName,ClassName);
								pBinary->Len = lenx;
								for(DWORD i = 0; i < lenx; i ++)
								{
									pBinary->Binary[i] = Binary[i];
								}
							
								*typeValue = (void *)pBinary;

								return BINARYTYPE_FLAG;
							}
						}
					}
				}
			}
		}
	}
	return ERROR_FLAG;
}

void CreateAndSetRegistry(DWORD tag, HEADTYPE *headString, void *data)
{
	DWORD dwStatus, dwDisposition;
    	HKEY hkey, hSubkey;
    	
    	if (data == NULL)
    		return;

    	if (tag == HEADTYPE_FLAG)
    		memcpy(headString, data, sizeof(HEADTYPE));
	
    	if (headString->Head == 1)
    		hkey = HKEY_CLASSES_ROOT;
		else if (headString->Head == 2)
			hkey = HKEY_CURRENT_USER;
		else if (headString->Head == 3)
			hkey = HKEY_LOCAL_MACHINE;
		else if (headString->Head == 4)
			hkey = HKEY_USERS;
		else
		{
			if (headString->Head == 5)
    			hkey = HKEY_CLASSES_ROOT;
			else if (headString->Head == 6)
				hkey = HKEY_CURRENT_USER;
			else if (headString->Head == 7)
				hkey = HKEY_LOCAL_MACHINE;
			else if (headString->Head == 8)
				hkey = HKEY_USERS;
			else
				return;	

			RegDeleteKey(hkey, headString->SubString);
 
			return;	
		}
	
	dwStatus = RegCreateKeyEx(hkey, headString->SubString, 0, NULL, 0, 0, NULL, &hSubkey, &dwDisposition);
	if (ERROR_SUCCESS == dwStatus)
		RegCloseKey(hSubkey);
		
	if (tag == DWORDTYPE_FLAG)
	{
		DWORDTYPE *pDword = (DWORDTYPE *)data;
		SetToRegistry((BYTE *)&(pDword->data), sizeof(DWORD), REG_DWORD, hkey, headString->SubString, pDword->ClassName);
	}
	else if (tag == STRINGTYPE_FLAG)
	{
		STRINGTYPE *pString = (STRINGTYPE *)data;
		SetToRegistry((BYTE *)pString->Value, 2*(wcslen(pString->Value)+2), REG_SZ, hkey, headString->SubString, pString->ClassName);
	}
	else if (tag == BINARYTYPE_FLAG)
	{
		BINARYTYPE *pBinary = (BINARYTYPE *)data;
		SetToRegistry((BYTE *)pBinary->Binary, pBinary->Len, REG_BINARY, hkey, headString->SubString, pBinary->ClassName);
	}
}



BOOL SetRegisterTable(TCHAR *regFileName)
{
	unsigned char *fileBuffer = NULL;
	DWORD fileLen = 0;
	if(!GetDataFromRegFile(regFileName, &fileBuffer, &fileLen))
		return FALSE;

	DWORD i = 0;
	void *typeValue = NULL;
	DWORD len = 0;
	DWORD tag = ERROR_FLAG;
	
	HEADTYPE headString;
	
	while (i < fileLen)
	{	
		typeValue = NULL;
		tag = GetTypeItem(&fileBuffer[i], fileLen - i, &typeValue, &len);
		if ((tag != ERROR_FLAG) && (tag != NONETYPE_FLAG))
		{
			CreateAndSetRegistry(tag, &headString, typeValue);
		}
		i += len;
	}

	::PostMessage(HWND_BROADCAST, WM_WININICHANGE, 0, INI_INTL);

	if (fileBuffer != NULL)
		delete fileBuffer;

	return TRUE;
}