getregfile.cpp

1,wince下做的导入注册表的程序.

// GetRegFileV.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
//#include "regmgr.h"
#include "GetRegFile.h"
#include "Embolog.h"
///////////////////////////////////////////////////////////////////////
//The following class EmboCmdLine is for input argc/argv from cmdline 
///////////////////////////////////////////////////////////////////////
///////////EmboCmdLine Class Begin/////////////////////////////////////
///////////////////////////////////////////////////////////////////////
class EmboCmdLine
{
#define MAX_ARG_COUNT 8	
public:
	int nArgCount;
	TCHAR szArg[MAX_ARG_COUNT][MAX_PATH];
	EmboCmdLine();
	BOOL SetArgC(int argc);
	BOOL SetArgV(TCHAR* argv[]);
};
typedef EmboCmdLine *PEmboCmdLine;

EmboCmdLine::EmboCmdLine()
{
	nArgCount=1;
			//int aa=sizeof(szArg);
	memset(szArg, 0, sizeof(szArg));
}
BOOL EmboCmdLine::SetArgC(int argc)
{
	if(MAX_ARG_COUNT<argc)
	{
		return FALSE;
	}
	nArgCount=argc;
	return TRUE;
}
BOOL EmboCmdLine::SetArgV(TCHAR* argv[])
{
	if(1>=nArgCount)
	{
		return FALSE;
	}
	for(int i=0;i<nArgCount;i++)
	{
		int j=i;
		_tcscpy(szArg[j], argv[j]);
	}
	return TRUE;
}
///////////////////////////////////////////////////////////////////////
///////////EmboCmdLine Class Emd //////////////////////////////////////
///////////////////////////////////////////////////////////////////////

//用来记录读取得内容，行数和列数
struct  FILE_CONTENT
{
public:
	DWORD lLine;				//行数
	PTCHAR pRawLinePtr;			//to point to the exact data to process afterwards
	TCHAR RawLine[MAX_PATH];

	FILE_CONTENT()				//构造函数
	{
		lLine=0;
		memset(RawLine, 0, sizeof(RawLine));
	}
};

PTCHAR EmboTrimLeft(PTCHAR pData)
{
	if((NULL==pData)||(NULL==*pData))return NULL;
	PTCHAR psz = pData;
	DWORD nSize=_tcslen(psz);
	while (_istspace(*psz))
	{
		*psz=NULL;
		nSize--;
		if(0==nSize)return NULL;
		psz++;
	}
	return psz;
}
PTCHAR EmboTrimRight(PTCHAR pData)
{
	if((NULL==pData)||(NULL==*pData))return NULL;
	PTCHAR psz = pData;
	DWORD nSize=_tcslen(psz);
	while (_istspace(psz[nSize-1]))
	{
		psz[nSize-1]=NULL;
		nSize--;
		if(0==nSize)return NULL;
	}
	return psz;
}

EmboLog g_AppLog("GetRegFile.exe");

//////////////////////////////////
//(1)using:
//EmboCmdLine sCmdLine;
//PEmboCmdLine pCmdLine;
//(2)using:
TCHAR szAddRegName[MAX_PATH];
BOOL fFindAddReg=FALSE;
//(3)using:
BOOL fReadfile=TRUE;
DWORD dwRetVal=statusError;
FILE *fileAddReg=NULL;
PTCHAR pszPtr=NULL;
int fRetValEof=0;
int fRetValErr=0;
FILE_CONTENT content;
RegValue_ARGS regArgs;

/////////////////////////////////////////////////////////
//This function get regArgs.dwRoot and regArgs.szPath
//from regArgs.szTempKeyLine
////////////////////////////////////////////////////////
BOOL Get_RegKey()
{
//(1), check inputs: regArgs.szTempKeyLine, regArgs.szPath
	BOOL fRegKey=FALSE; 
	PTCHAR pszFindPtr=NULL;
	//All we do is from regArgs.szTempKeyLine, 
	//which is full by regArgs.pszTempKeyLine,
	//We use pszPtr here.
	PTCHAR pszPtr=regArgs.szTempKeyLine;
	//If input too large?
	DWORD nszSize=_tcslen(pszPtr);
	if((MAX_PATH-1)<=nszSize)
	{
		fRegKey=FALSE;
		goto GetRegKey_return;
	}
	//Clear regArgs.szPath
	memset(regArgs.szPath, 0, sizeof(TCHAR)*MAX_PATH); 

//(2), work begin:
	pszPtr+=1;	//Skip '['
	if(_T('-')==pszPtr[0])	//if it is to delete key
	{
		pszPtr+=1;
		regArgs.bDeleteKey=TRUE;
	}
//(2.1), get regArgs.dwRoot
	//2.1.1, if root is HKEY_LOCAL_MACHINE
	pszFindPtr=_tcsstr(pszPtr, _T("HKEY_LOCAL_MACHINE"));
	if(pszFindPtr==pszPtr)
	{
		regArgs.dwRoot=HKEY_LOCAL_MACHINE;
		nszSize=_tcslen(_T("HKEY_LOCAL_MACHINE"))+1;
		pszPtr+=nszSize;
		goto Copy_szPath;
	}

	//2.1.2, if root is HKEY_CLASSES_ROOT
	pszFindPtr=_tcsstr(pszPtr, _T("HKEY_CLASSES_ROOT"));
	if(pszFindPtr==pszPtr)
	{
		regArgs.dwRoot=HKEY_CLASSES_ROOT;
		nszSize=_tcslen(_T("HKEY_CLASSES_ROOT"))+1;
		pszPtr+=nszSize;
		goto Copy_szPath;
	}

	//2.1.3, if root is HKEY_CURRENT_USER
	pszFindPtr=_tcsstr(pszPtr, _T("HKEY_CURRENT_USER"));
	if(pszFindPtr==pszPtr)
	{
		regArgs.dwRoot=HKEY_CURRENT_USER;
		nszSize=_tcslen(_T("HKEY_CURRENT_USER"))+1;
		pszPtr+=nszSize;
		goto Copy_szPath;
	}

	//2.1.4, if root is HKEY_USERS
	pszFindPtr=_tcsstr(pszPtr, _T("HKEY_USERS"));
	if(pszFindPtr==pszPtr)
	{
		regArgs.dwRoot=HKEY_USERS;
		nszSize=_tcslen(_T("HKEY_USERS"))+1;
		pszPtr+=nszSize;
		goto Copy_szPath;
	}
//(2.2), get regArgs.szPath
Copy_szPath:
	nszSize=_tcslen(pszPtr)-1;	//ignore the last ']'
	_tcsncpy(regArgs.szPath, pszPtr, nszSize);

	//(3), return
GetRegKey_return:
	return fRegKey;
}
BOOL SetRegKey(RegValue_ARGS* pregArgs)
{
	BOOL fRet=FALSE;
	DWORD dwRegResult=0;
	dwRegResult=RegCreateKeyEx(regArgs.dwRoot, regArgs.szPath,
						0, regArgs.szClass, regArgs.dwRegOptions,
							0, NULL, 
							&regArgs.hCurKey, &regArgs.dwDisposition );
  	if(ERROR_SUCCESS==dwRegResult)
	{
		fRet=TRUE;
		RegCloseKey(regArgs.hCurKey);
	}
	else
	{
		DEBUGMSG(1,(_T("Error: Can not write Key %s to Registry！"), regArgs.szPath));
		fRet=FALSE;
	}
	return fRet;
}


BOOL SetRegVaulue(RegValue_ARGS* pregArgs)
{
	BOOL fRet=FALSE;
	DWORD dwRegResult=0;
	dwRegResult=RegCreateKeyEx(regArgs.dwRoot, regArgs.szPath,
						0, regArgs.szClass, regArgs.dwRegOptions,
							0, NULL, 
							&regArgs.hCurKey, &regArgs.dwDisposition );
  	if(ERROR_SUCCESS==dwRegResult)
	{
		dwRegResult=RegSetValueEx(regArgs.hCurKey, regArgs.szName, 
 					0, regArgs.dwType, (const BYTE *)regArgs.ValueBuf, regArgs.dwHexDataLen);
		if(ERROR_SUCCESS==dwRegResult)
		{
			fRet=TRUE;
		}
		else
		{
			DEBUGMSG(1,(_T("Error: Can not write %s to Registry！"), regArgs.szName));
			fRet=FALSE;
		}
		RegCloseKey(regArgs.hCurKey);
	}
	else
	{
		fRet=FALSE;
	}
	return fRet;
}

BOOL ClrDblSlash(PTCHAR szValuePtr)
{
	TCHAR szTemp[MAX_PATH]={0};
	PTCHAR p1stSlash=NULL;
	PTCHAR p2ndSlash=NULL;
	PTCHAR pCurrent=szValuePtr;
	BOOL fRetClrDblSlash=TRUE;
	DWORD nLength=_tcslen(szValuePtr);
	DWORD nTailLength=0;
	DWORD nDblSlash=0;

	if(MAX_PATH<=nLength)
	{
		fRetClrDblSlash=FALSE;
		return fRetClrDblSlash;
	}

	do
	{
		p1stSlash=_tcschr(pCurrent, _T('\\'));
		if(NULL!=p1stSlash)
		{
			pCurrent=p1stSlash+1;
			if(_T('\\')==*pCurrent)
			{
				memset(szTemp, 0, sizeof(szTemp));
				_tcscpy(szTemp, pCurrent+1);
				nTailLength=_tcslen(szTemp);
				_tcscpy(pCurrent, szTemp);
				pCurrent[nTailLength]=NULL;

			}
		}
		else
		{
			return fRetClrDblSlash;

		}

	}while(TRUE);
}

/////////////////////////////////////////////////////////
//This function get regArgs.dwType, regArgs.ValueBuf, regArgs.dwHexDataLen
//from regArgs.szTempValueLine
////////////////////////////////////////////////////////
BOOL GetValueBuf(RegValue_ARGS* pregArgs, PTCHAR pszValuePtr)
{
	BOOL fRet=FALSE;
	memset(regArgs.ValueBuf, 0, sizeof(regArgs.ValueBuf));
	PTCHAR szValuePtr=pszValuePtr;
	DWORD nszSize=_tcslen(szValuePtr);
	TCHAR	*stopstring;
	ULONG kk=0;
	//If string?
	if( (_T('"')==szValuePtr[0])&&(_T('"')==szValuePtr[nszSize-1]) )
	{
		regArgs.dwType=REG_SZ;
				////////////Embo Add 20060224
		ClrDblSlash(szValuePtr);
				////////////Embo Add 20060224
		_tcsncpy((PTCHAR)regArgs.ValueBuf, &szValuePtr[1], (nszSize-2));
		regArgs.dwHexDataLen=sizeof(TCHAR)*(_tcslen((PTCHAR)regArgs.ValueBuf)+1);
		fRet=SetRegVaulue(&regArgs);
		goto GetValueBuf_Return;
	}
	//If DWORD?
	if( (0==(_tcsncmp(szValuePtr, _T("DWORD:"), _tcslen(_T("DWORD:"))))) ||
		(0==(_tcsncmp(szValuePtr, _T("dword:"), _tcslen(_T("dword:"))))) 
		)
	{
		regArgs.dwType=REG_DWORD;
		szValuePtr+=_tcslen(_T("dword:"));
		szValuePtr=EmboTrimLeft(szValuePtr);
		szValuePtr=EmboTrimRight(szValuePtr);
		if(NULL==szValuePtr)
		{
			fRet=FALSE;
			goto GetValueBuf_Return;
		}
		_tcslwr(szValuePtr);
		ULONG ulTemp=_tcstoul(szValuePtr, &stopstring, 0x10);
		memcpy(regArgs.ValueBuf, (PUCHAR)&ulTemp, sizeof(DWORD));
		regArgs.dwHexDataLen=sizeof(DWORD);
		fRet=SetRegVaulue(&regArgs);
		goto GetValueBuf_Return;
	}
	//If REG_MULTI_SZ, multi_sz:
	if( (0==(_tcsncmp(szValuePtr, _T("MULTI_SZ:"), _tcslen(_T("MULTI_SZ:"))))) ||
		(0==(_tcsncmp(szValuePtr, _T("multi_sz:"), _tcslen(_T("multi_sz:"))))) 
		)
	{
		regArgs.dwType=REG_MULTI_SZ;
		szValuePtr+=_tcslen(_T("multi_sz:"));
		szValuePtr=EmboTrimLeft(szValuePtr);
		szValuePtr=EmboTrimRight(szValuePtr);
		if(NULL==szValuePtr)
		{
			fRet=FALSE;
			goto GetValueBuf_Return;
		}
		BOOL fLastBlock=FALSE;
		PTCHAR pszFindBreak=NULL;
		PTCHAR pszFindBegin=szValuePtr;
		PTCHAR pszFindEnd=szValuePtr+_tcslen(szValuePtr);
		PTCHAR pszCopySrcPtr=szValuePtr;
		PTCHAR pszCopyDstPtr=(PTCHAR)regArgs.ValueBuf;
		//DWORD nSrcSize=_tcslen(szValuePtr);;
		DWORD nCopySize=0;
		DWORD nMultiCopySize=0;
		do
		{
			pszFindBreak=_tcspbrk(pszFindBegin, _T(","));
			if(NULL!=pszFindBreak) 
			{
		DO_ONE_Block:
				*pszFindBreak=NULL;
				//do string from "pszFindBegin-->pszFindBreak"
				pszFindBegin=EmboTrimLeft(pszFindBegin);
				pszFindBegin=EmboTrimRight(pszFindBegin);
				TCHAR s=pszFindBegin[0];
				int jj=_tcslen(pszFindBegin)-1;
				TCHAR s2=pszFindBegin[jj];
				if((NULL==pszFindBegin)||
					(_T('"')!=pszFindBegin[0])||
					(_T('"')!=pszFindBegin[_tcslen(pszFindBegin)-1])
					)	
				{
					fRet=FALSE;
					goto GetValueBuf_Return;
				}
				////////////Embo Add 20060224
				TCHAR szTempFindBegin[MAX_PATH]={0};
				_tcscpy(szTempFindBegin, pszFindBegin);
				ClrDblSlash(szTempFindBegin);
				////////////Embo Add 20060224
				nCopySize=_tcslen(szTempFindBegin);
				_tcsncpy(pszCopyDstPtr, &szTempFindBegin[1], (nCopySize-2));
				pszCopyDstPtr+=(nCopySize-1);
				nMultiCopySize+=(nCopySize-1);
				pszFindBegin=pszFindBreak+1;
				if(TRUE==fLastBlock) break;
				continue;
			}
			else
			{
				fLastBlock=TRUE;
				pszFindBreak=pszFindEnd;
				goto DO_ONE_Block;
			}
		}while(1);

		regArgs.dwHexDataLen=(nMultiCopySize+1)*sizeof(TCHAR);

		fRet=SetRegVaulue(&regArgs);
		
		goto GetValueBuf_Return;
	}
//////////////////////EmboAdd 20060224
	if( (0==(_tcsncmp(szValuePtr, _T("hex(7):"), _tcslen(_T("hex(7):"))))) ||
		(0==(_tcsncmp(szValuePtr, _T("HEX(7):"), _tcslen(_T("hex(7):"))))) 
		)
	{
		regArgs.dwType=REG_MULTI_SZ;
		szValuePtr+=_tcslen(_T("hex(7):"));
		szValuePtr=EmboTrimLeft(szValuePtr);
		szValuePtr=EmboTrimRight(szValuePtr);
		if(NULL==szValuePtr)
		{
			fRet=FALSE;
			goto GetValueBuf_Return;
		}
		DWORD nBreak=0;
		//TCHAR szHexData[8192]={0};

		BOOL fLastBlock=FALSE;
		PTCHAR pszFindBreak=NULL;
		PTCHAR pszFindBegin=szValuePtr;
		PTCHAR pszFindEnd=szValuePtr+_tcslen(szValuePtr);
		PTCHAR pszCopySrcPtr=szValuePtr;
		PTCHAR pszCopyDstPtr=(PTCHAR)regArgs.ValueBuf;;
		//DWORD nSrcSize=_tcslen(szValuePtr);;
		//DWORD nCopySize=0;
		//DWORD nMultiCopySize=0;
		do
		{
			pszFindBreak=_tcspbrk(pszFindBegin, _T(","));
			if(NULL!=pszFindBreak) 
			{
		DO_ONE_Block_hex7:
				*pszFindBreak=NULL;
				//do string from "pszFindBegin-->pszFindBreak"
				pszFindBegin=EmboTrimLeft(pszFindBegin);
				pszFindBegin=EmboTrimRight(pszFindBegin);
				TCHAR s=pszFindBegin[0];
				int jj=_tcslen(pszFindBegin)-1;
				TCHAR s2=pszFindBegin[jj];
				if((NULL==pszFindBegin)
					||(2!=_tcslen(pszFindBegin))
					//(_T('"')!=pszFindBegin[0])||
					//(_T('"')!=szValuePtr[_tcslen(pszFindBegin)-1])
					)	
				{
					fRet=FALSE;
					goto GetValueBuf_Return;
				}
				ULONG ulTemp=_tcstoul(pszFindBegin, &stopstring, 0x10);
				//nCopySize=_tcslen(pszFindBegin);
				//UCHAR ulTemp=(UCHAR)((ULONG)*pszFindBegin-*0x10)+(UCHAR)
				*pszCopyDstPtr=(TCHAR)ulTemp;
				pszCopyDstPtr+=1;
				nBreak+=1;
				if(TRUE==fLastBlock) break;
				pszFindBegin=pszFindBreak+1;
				continue;
			}
			else
			{
				fLastBlock=TRUE;
				pszFindBreak=pszFindEnd;
				goto DO_ONE_Block_hex7;
			}
		}while(1);

		regArgs.dwHexDataLen=(nBreak+1)*sizeof(TCHAR);
		fRet=SetRegVaulue(&regArgs);
		goto GetValueBuf_Return;
	}
//////////////////////EmboAdd 20060224
	//If REG_BINARY, hex:
	if( (0==(_tcsncmp(szValuePtr, _T("HEX:"), _tcslen(_T("HEX:"))))) ||
		(0==(_tcsncmp(szValuePtr, _T("hex:"), _tcslen(_T("hex:"))))) 
		)
	{
		regArgs.dwType=REG_BINARY;
		szValuePtr+=_tcslen(_T("hex:"));
		szValuePtr=EmboTrimLeft(szValuePtr);
		szValuePtr=EmboTrimRight(szValuePtr);
		if(NULL==szValuePtr)
		{
			fRet=FALSE;
			goto GetValueBuf_Return;
		}
		DWORD nBreak=0;
		//TCHAR szHexData[8192]={0};

		BOOL fLastBlock=FALSE;
		PTCHAR pszFindBreak=NULL;
		PTCHAR pszFindBegin=szValuePtr;
		PTCHAR pszFindEnd=szValuePtr+_tcslen(szValuePtr);
		PTCHAR pszCopySrcPtr=szValuePtr;
		PUCHAR pszCopyDstPtr=regArgs.ValueBuf;;
		//DWORD nSrcSize=_tcslen(szValuePtr);;
		//DWORD nCopySize=0;
		//DWORD nMultiCopySize=0;
		do
		{
			pszFindBreak=_tcspbrk(pszFindBegin, _T(","));
			if(NULL!=pszFindBreak) 
			{
		DO_ONE_Block_hex:
				*pszFindBreak=NULL;
				//do string from "pszFindBegin-->pszFindBreak"
				pszFindBegin=EmboTrimLeft(pszFindBegin);
				pszFindBegin=EmboTrimRight(pszFindBegin);
				TCHAR s=pszFindBegin[0];
				int jj=_tcslen(pszFindBegin)-1;
				TCHAR s2=pszFindBegin[jj];
				if((NULL==pszFindBegin)
					||(2!=_tcslen(pszFindBegin))
					//(_T('"')!=pszFindBegin[0])||
					//(_T('"')!=szValuePtr[_tcslen(pszFindBegin)-1])
					)	
				{
					fRet=FALSE;
					goto GetValueBuf_Return;
				}
				ULONG ulTemp=_tcstoul(pszFindBegin, &stopstring, 0x10);
				//nCopySize=_tcslen(pszFindBegin);
				*pszCopyDstPtr=(UCHAR)ulTemp;
				pszCopyDstPtr++;
				nBreak+=1;
				if(TRUE==fLastBlock) break;
				pszFindBegin=pszFindBreak+1;
				continue;
			}
			else
			{
				fLastBlock=TRUE;
				pszFindBreak=pszFindEnd;
				goto DO_ONE_Block_hex;
			}
		}while(1);

		regArgs.dwHexDataLen=nBreak;
		fRet=SetRegVaulue(&regArgs);
		goto GetValueBuf_Return;
	}

GetValueBuf_Return:	
	return fRet ;
}

/////////////////////////////////////////////////////////
//This function get regArgs.bDeleteValue and regArgs.szName
//from regArgs.szTempValueLine
////////////////////////////////////////////////////////
BOOL Get_RegValue()
{
	BOOL fRet=FALSE;
	DWORD nszSize=0;

	memset(regArgs.szName, 0, sizeof(regArgs.szName));
	//
	PTCHAR szNamePtr=regArgs.szTempValueLine;
	PTCHAR szValuePtr=NULL;
	szValuePtr=_tcspbrk(regArgs.szTempValueLine, _T("="));
	if(NULL==szValuePtr)
	{
		fRet=FALSE;
		goto Get_RegValue_Return;
	}
	*szValuePtr=NULL;
	szValuePtr+=1;
	//2.1 Set regArgs.bDeleteValue
	if(_T('-')==*szValuePtr)
	{
		regArgs.bDeleteValue=TRUE;
		szValuePtr+=1;
	}
	else
	{
		regArgs.bDeleteValue=FALSE;
	}

	//2.2 Set regArgs.szName
	szNamePtr=EmboTrimLeft(szNamePtr);