regview.cpp

windows ce5.0 注册表文件的读取

		MessageBox(hwndMain,szOut,TEXT("import"),IDOK);
		*/
	}
	CloseHandle(hFile);
	return 1;
}
/*
void Import(LPTSTR szIn)
{
	TCHAR *pKeyBlock;
	TCHAR seps[]   = TEXT("\n");

    pKeyBlock= wcstok( szIn,seps);
	while( pKeyBlock != NULL )
	{
		//While there are tokens in "szIn" 
		//lstrcpy(szKeyBlocks[iCnt++],pKeyBlock);
		RegKey regKey;	
		TCHAR szOut[KEYBLOCK_SIZE_MAX]=TEXT("");
		ProcessKeyBlock(pKeyBlock,hWnd,&regKey);
		regKey.ToString(szOut);
		MessageBox(hWndMain,szOut,TEXT(""),IDOK);		
		// Get next token: 
		pKeyBlock = wcstok( pKeyBlock+lstrlen(pKeyBlock)+1, seps );
	}
}
*/
void ProcessKeyBlock(LPTSTR pKeyBlock,RegKey *regKey)
{
	
	TCHAR seps[] = TEXT("\n");
	TCHAR *pLine;
	TCHAR szKeyName[REGKEYNAME_SIZE_MAX]=TEXT("");
	TCHAR szKeyBlock[KEYBLOCK_SIZE_MAX];

	lstrcpy(szKeyBlock,pKeyBlock);
	pLine=wcstok(szKeyBlock,seps);
	if (pLine==NULL)
	{	
		lstrcpy(szKeyName,szKeyBlock);
		ProcessItemName(szKeyName);
		regKey->Init(szKeyName);
	}
	else
	{
		lstrcpy(szKeyName,pLine);
		ProcessItemName(szKeyName);
		regKey->Init(szKeyName);		
		pLine = wcstok(pLine+lstrlen(pLine)+1, seps );
		while (pLine!=NULL)
		{
			RegItem regItem;
			ProcessItemLine(pLine,regItem);

			regKey->AddItem(regItem.szName,regItem.szValue,regItem.wItemType);

			//pLine = wcstok( pLine+lstrlen(pLine)+1, seps );
			pLine = wcstok( NULL, seps );
		}
	}
	
}

void ProcessItemLine(LPTSTR pItemLine,RegItem &regItem)
{
	TCHAR seps[] = TEXT("=");
	TCHAR *pszNamePart,szNamepart[REGITEMNAME_SIZE_MAX];
	TCHAR *pszValuepart,szValuepart[SZLENGTH_MAX];
	TCHAR szItemLine[SZLENGTH_MAX];
	lstrcpy(szItemLine,pItemLine);
	pszNamePart=wcstok(szItemLine,seps);
	pszValuepart=wcstok(pszNamePart+lstrlen(pszNamePart)+1,seps);	
	lstrcpy(szNamepart,pszNamePart);
	lstrcpy(szValuepart,pszValuepart);
	ProcessItemName(szNamepart);
	lstrcpy(regItem.szName,szNamepart);
	ProcessItemValue(pszValuepart,regItem.szValue,regItem.wItemType);
}

//去处Itemname两头的符号--tested
void ProcessItemName(LPTSTR pItemName)
{
	/*
	TCHAR seps[] = TEXT("\"");
	TCHAR *pName;
	pName=wcstok(pItemName,seps);
	lstrcpy(pItemName,pName);
	*/
	//if (pItemName[lstrlen(pItemName-)]==(TCHAR)'\"')
	pItemName[lstrlen(pItemName)-1]=0;
	lstrcpy(pItemName,pItemName+1);
	
}

//在值中分解出类型和值
void ProcessItemValue(LPTSTR pItemValue,LPTSTR pRealValue,DWORD &wType)
{
	TCHAR seps[] = TEXT(":");
	TCHAR *pszFirstPart;
	TCHAR *pszSecondPart;
	TCHAR szItemValue[SZLENGTH_MAX];

	lstrcpy(szItemValue,pItemValue);
	pszFirstPart=wcstok(szItemValue,seps);
	if(lstrlen(pszFirstPart)==lstrlen(pItemValue))
		pszSecondPart=NULL;
	else
		pszSecondPart=wcstok(pszFirstPart+lstrlen(pszFirstPart)+1,seps);
	if (pszSecondPart==NULL)//没有":",wType=REG_SZ
	{
		wType=REG_SZ;
		lstrcpy(pRealValue,pszFirstPart);
		ProcessItemName(pRealValue);	//去除ItemValue两头的引号
	}
	else
	{
		if(lstrcmp(pszFirstPart,TEXT("hex"))==0)
		{
			wType=REG_BINARY;
			lstrcpy(pRealValue,pszSecondPart);
		}
		else if (lstrcmp(pszFirstPart,TEXT("hex(7)"))==0)
		{
			wType=REG_MULTI_SZ;
			lstrcpy(pRealValue,pszSecondPart);
		}else if (lstrcmp(pszFirstPart,TEXT("dword"))==0)
		{
			wType=REG_DWORD;
			lstrcpy(pRealValue,pszSecondPart);
		}
	}
	ProcessItemRealValue(pRealValue);
}

//去除读取的值中的换行标识和开头的六个空格
void ProcessItemRealValue(LPTSTR pRealValue)
{
	/*
	TCHAR *pRetValue=(TCHAR *)malloc((lstrlen(pRealValue)+1)*sizeof(TCHAR));
	//TCHAR pRetValue[255];
	TCHAR seps[] = TEXT("\\\n      ");
	TCHAR *pWord;
	lstrcpy(pRetValue,TEXT(""));
	pWord=wcstok(pRealValue,seps);
	while (pWord!=pRealValue)
	{
		lstrcat(pRetValue,pWord);
		pRealValue=pWord+lstrlen(pWord)+1;
		pWord=wcstok(pRealValue,seps);
	}
	lstrcpy(pRealValue,pRetValue);
	free(pRetValue);
	*/

}


//列举pszKey的所有子键
LRESULT GetChildren (HKEY hRoot,LPTSTR pszKey,PRegKey pRegKey,BOOL boolJustname) {
    INT i = 0, rc;
    DWORD dwNSize;
    DWORD dwCSize;
    TCHAR szName[MAX_PATH];
    TCHAR szClass[256];
    FILETIME ft;
    HKEY hKey;

    // All keys but root need to be opened.
    if (lstrlen (pRegKey->szName)) {
        if (RegOpenKeyEx (hRoot, pszKey, 0, 0, &hKey) != ERROR_SUCCESS) {
            rc = GetLastError();
            return 0;
        }
    } else 
        hKey=hRoot;

    dwNSize = dim(szName);
    dwCSize = dim(szClass);
    rc = RegEnumKeyEx (hKey, i, szName, &dwNSize, NULL,
                       szClass, &dwCSize, &ft);
    while (rc == ERROR_SUCCESS) {

        RegKey child;
		//获取子键绝对路径
		TCHAR szChildname[REGKEYNAME_SIZE_MAX]=TEXT("");
		TCHAR szChildKey[REGKEYNAME_SIZE_MAX]=TEXT("");
		lstrcat(szChildKey,pszKey);
		lstrcat(szChildKey,TEXT("\\"));
		lstrcat(szChildKey,szName);
		GetFullPath(hRoot,szChildKey,szChildname);

		child.Init(szChildname);

		if (!boolJustname)
		{
			GetValues(hRoot,szChildKey,&child);
			
			GetChildren(hRoot,szChildKey,&child,boolJustname);
		}

		pRegKey->AddChild(child);

        dwNSize = dim(szName);
        rc = RegEnumKeyEx (hKey, ++i, szName, &dwNSize,
                           NULL, NULL, 0, &ft);
    }
    // If this wasn't the a root key, close it.
    if (hKey != hRoot)
        RegCloseKey (hKey);

    return i;
}


//列举pszKey的所有值
LRESULT GetValues (HKEY hRoot,LPTSTR pszKey,PRegKey pRegKey) {
    INT nCnt = 0, rc;
    DWORD dwNSize, dwDSize, dwType;
    TCHAR szName[MAX_PATH];
    BYTE bData[1024];
    HKEY hKey;

    if (lstrlen (pszKey)) {
        if (RegOpenKeyEx (hRoot, pszKey, 0, 0, &hKey) != ERROR_SUCCESS)
            return 0;
    } else 
        hKey = hRoot;


    // Enumerate the values,save to RegKey
    nCnt = 0;
    dwNSize = dim(szName);
    dwDSize = dim(bData);
    rc = RegEnumValue (hKey, nCnt, szName, &dwNSize,
                       NULL, &dwType, bData, &dwDSize);

    while (rc == ERROR_SUCCESS) {
        // save to RegKey
		TCHAR szValue[SZLENGTH_MAX];
		BDataToSZ(bData,dwDSize,dwType,szValue);
		pRegKey->AddItem(szName,szValue,dwType);
	
        dwNSize = dim(szName);
        dwDSize = dim(bData);
        nCnt++;
        rc = RegEnumValue (hKey, nCnt, szName, &dwNSize,
                           NULL, &dwType, bData, &dwDSize);
    }
  
    if (hKey != hRoot)
        RegCloseKey (hKey);
	
    return 1;
}

void BDataToSZ(PBYTE pbData,DWORD dwDSize, DWORD dwType,LPTSTR szData)
{    
    INT i, len;
	int step=1;
	BOOL prevZero=FALSE;
	
    switch (dwType) {
    case REG_EXPAND_SZ:
    case REG_SZ:
        lstrcpy (szData, (LPTSTR)pbData);
        break;

    case REG_DWORD:
        wsprintf (szData, TEXT ("%08X"), *(int *)pbData);
        break;
		
	case REG_MULTI_SZ:
		 step=2;
    case REG_BINARY:
        szData[0] = TEXT ('\0');
        for (i = 0; i < (int)dwDSize; i+=step) {
            len = lstrlen (szData);
			if (i!=(int)dwDSize-step)
				wsprintf (&szData[len], TEXT ("%02X,"), pbData[i]);
			else
				wsprintf (&szData[len], TEXT ("%02X"), pbData[i]);
            if (len > dim(szData) - 6)
                break;
        }
		
        break;
    default:
        wsprintf (szData, TEXT ("Unknown type: %x"), dwType);
    }
}

//将字符串表示的值转换成字节流
void SZToBData(LPTSTR szData,DWORD dwType,PBYTE &pbData,DWORD &dwDSize)
{

			switch(dwType)
			{
			case REG_EXPAND_SZ:
			case REG_SZ:
				pbData=(BYTE *)szData;
				dwDSize=(lstrlen(szData)+1)*2;
				break;
			case REG_DWORD:
				pbData=(BYTE *)malloc(4);
				swscanf(szData,TEXT("%08X"),pbData);
				/*
				pbData[3]=LOBYTE(LOWORD(wData));
				pbData[2]=HIBYTE(LOWORD(wData));
				pbData[0]=LOBYTE(HIWORD(wData));
				pbData[1]=HIBYTE(HIWORD(wData));
				*/
				dwDSize=sizeof(DWORD);
			    break;
			case REG_MULTI_SZ:
				{
					TCHAR szTemp[SZLENGTH_MAX]=TEXT("");
					pbData=(BYTE *)malloc(lstrlen(szData)/2);
					int i=0,rc=1;
					lstrcpy(szTemp,szData);
					while(lstrlen(szTemp)>2)
					{
						rc=swscanf(szTemp,TEXT("%02X,%s"),(TCHAR *)&pbData[i],szTemp);
						i+=2;
					}
					swscanf(szTemp,TEXT("%02X"),&pbData[i]);
					i+=2;
					dwDSize=i;
					
					
					break;
					
				}
			case REG_BINARY:
				{
					TCHAR szTemp[SZLENGTH_MAX];
					pbData=(BYTE *)malloc(lstrlen(szData)/2);
					int i=0,rc=1;
					lstrcpy(szTemp,szData);
					while(lstrlen(szTemp)>2)
						rc=swscanf(szTemp,TEXT("%02X,%s"),&pbData[i++],szTemp);
					swscanf(szTemp,TEXT("%02X"),&pbData[i++]);
					dwDSize=i;
					break;
					
				}
				break;
			default:
				break;
			}	
}

void GetFullPath(HKEY hRoot,LPTSTR szKey,LPTSTR szFullpath)
{
				TCHAR szRoot[REGKEYNAME_SIZE_MAX]=TEXT("");
				HRootToSZ(hRoot,szRoot);
				lstrcat(szFullpath,szRoot);
				lstrcat(szFullpath,szKey);
}

void HRootToSZ(HKEY hRoot,LPTSTR szRoot)
{
	lstrcpy(szRoot,TEXT(""));	
	if(HKEY_CLASSES_ROOT==hRoot)
		lstrcpy(szRoot,TEXT("HKEY_CLASSES_ROOT"));
	if(HKEY_CURRENT_USER==hRoot)
		lstrcpy(szRoot,TEXT("HKEY_CURRENT_USER"));
	if(HKEY_LOCAL_MACHINE==hRoot)
		lstrcpy(szRoot,TEXT("HKEY_LOCAL_MACHINE"));
	if(HKEY_USERS==hRoot)
		lstrcpy(szRoot,TEXT("HKEY_USERS"));
}

INT GetFileName (HWND hWnd, LPTSTR szFileName, INT nMax) {
    OPENFILENAME of;
    const LPTSTR pszOpenFilter = TEXT ("All Documents (*.*)\0*.*\0\0");

    szFileName[0] = '\0';                 // Initial filename
    memset (&of, 0, sizeof (of));         // Initial file open structure

    of.lStructSize = sizeof (of);
    of.hwndOwner = hWnd;
    of.lpstrFile = szFileName;
    of.nMaxFile = nMax;
    of.lpstrFilter = pszOpenFilter;
    of.Flags = 0;

    if (GetOpenFileName (&of))
        return lstrlen (szFileName);
    else
        return 0;
}

DWORD ReadBlock(HANDLE hFile,DWORD iStartPos,TCHAR sep,LPTSTR szBlock,BOOL boolSepStart)
{
	TCHAR c;
	DWORD nNum=0;
	DWORD retPoint;
	int iIndex=0;
	
	memset(szBlock,0,255);

	SetFilePointer(hFile,iStartPos,NULL,FILE_BEGIN);
	ReadFile(hFile,&c,sizeof(TCHAR),&nNum,NULL);
	
	while (c!=sep)
	{
		if (nNum==0)
			return -1;//到文件尾部,还没有发现sep
		ReadFile(hFile,&c,sizeof(TCHAR),&nNum,NULL);
	}
	if (boolSepStart)
		szBlock[iIndex++]=(TCHAR)c;//c==sep

	ReadFile(hFile,&c,sizeof(TCHAR),&nNum,NULL);
	while (c!=sep)
	{
		if (nNum==0)
		{
			szBlock[iIndex++]=0;
			return 0;//到文件尾部,已经发现了sep
		}
		szBlock[iIndex++]=(TCHAR)c;
		ReadFile(hFile,&c,sizeof(TCHAR),&nNum,NULL);
	}
	szBlock[iIndex++]=0;

	retPoint=SetFilePointer(hFile,-1,NULL,FILE_CURRENT);

	return retPoint-1;//返回当前位置到文件头的距离
}