registry_db.cpp

手机数据备份软件

				savedSize=0;
				if (sr.isValue) {	// value
					readStatus=REGVALUE;
				} else {	// key
					readStatus=REGHEAD;
					// create key here
//if (!wcscmp(keyName,L"Windows CE Tools"))
//	int a=0;
					if (sr.depath==0) { // root key
						int i=0;
						while(krName[i]) {
							if (!wcscmp(krName[i],sr.keyName)) break;
							i++;
						}
						if (hKeyRoot[i]) {
							if (!BackKeyNode(keyNode,keyNameList,0,isKeyLast,kNode))
							{
								savedFile.Close();
								return FALSE;
							}
							kNode.hKey=hKeyRoot[i];
							kNode.depath=sr.depath;
							keyNode.RemoveAll();
							keyNode.Add(kNode);
						} else {
							CString Msg;
							Msg.LoadString(MSG_BKFILE_ERROR);
							::MessageBox(NULL,Msg,BACKUPTITLE,MB_OK|MB_ICONEXCLAMATION|MB_ICONERROR);
							savedFile.Close();
							return FALSE;
						}
					} else {
						if (!BackKeyNode(keyNode,keyNameList,sr.depath-1,isKeyLast,kNode))
						{
							savedFile.Close();
							return FALSE;
						}
						DWORD method;
						if (RegCreateKeyEx(kNode.hKey,sr.keyName,
									NULL,NULL,NULL,NULL,NULL,
									&kNode.hKey,&method)==ERROR_SUCCESS) {
							kNode.depath=sr.depath;
							keyNode.Add(kNode);
						} else {
//							AfxMessageBox(L"Create key error!!!");
						}
					}
					isKeyLast=TRUE;
				}
			}}
			break;
		case REGVALUE:
			{int nSize=sr.keyValueSize-savedSize;
			int remainBuf=bufEnd-buf;
			UCHAR* pTmp;
			pTmp=valueData;
			pTmp+=savedSize;
			if (nSize>remainBuf) {
				memcpy(pTmp,buf,remainBuf);
				savedSize+=remainBuf;
				continue;
			} else {
				memcpy(pTmp,buf,nSize);
//				ProgressBarStepUP(savedSize+nSize);
				m_pProgressWnd->SetProgressPos(savedSize+nSize);

				buf+=nSize;
				savedSize=0;
				readStatus=REGHEAD;
				sr.keyValue=valueData;
				if (!BackKeyNode(keyNode,keyNameList,sr.depath,isKeyLast,kNode))
				{
					savedFile.Close();
					return FALSE;
				}
				// add value name into list
				if (isKeyLast) {
					// enum key value into list;
					int vIndex=0;
					DWORD keyNameLen=MAX_PATH;
					CString cs=keyName;
					while (RegEnumValue(kNode.hKey, vIndex++, keyName, &keyNameLen, NULL, NULL,NULL,NULL)==ERROR_SUCCESS) {
						keyNameList.AddTail(keyName);
						keyNameLen=MAX_PATH;
					}
					wcscpy(keyName, cs.GetBuffer(0));
					isKeyLast = FALSE;
				}
				//

				// delete same key value in the list
				POSITION pos=keyNameList.Find(keyName);
				if (pos) keyNameList.RemoveAt(pos);
				//

				// is it need compare value to determin set value?
				if (RegSetValueEx(kNode.hKey,sr.keyName,NULL,
								sr.keyValueType,sr.keyValue,
								sr.keyValueSize)!=ERROR_SUCCESS) {

				}
				isKeyLast=FALSE;
			}}
			break;
		default:
			break;
		}
		if (buf<bufEnd)	goto LOOPHERE;
	}
	delete[] buffers;
	delete[] valueData;
	delete[] keyName;
	DeleteKey();
	savedFile.Close();
/*	hkRoot=hKeyRoot;
	while (*hkRoot) {
		RegFlushKey(*hkRoot);
		hkRoot++;
	}*/

	return TRUE;
}

//////////////////////////////////////////////////////////////////
// get size of Database for backup
// PARAMETER:
//		 DBname   ---- database's name
// RETURN VALUE: 
//       if success return size of database, otherwise return -1
// AUTOTHOR: sunyh
// VERSION: 1.0        
//////////////////////////////////////////////////////////////////

DWORD CRegistry_DB::GetBackupDBSize(LPWSTR DBName)
{
	CEOID ceoid = 0;
	if (CeOpenDatabase(&ceoid,DBName,0,0,NULL) == INVALID_HANDLE_VALUE )
		return -1;
	CEOIDINFO CeObjectInfo;
	if(!CeOidGetInfo(ceoid,&CeObjectInfo))
		return -1;
	return CeObjectInfo.infDatabase.dwSize;
	
/*	CCeDBDatabase database;
	if (!database.Open(DBName))
		return -1;
	DWORD dbsize = database.GetSize();
	database.Close();
	return dbsize;
*/
}
//////////////////////////////////////////////////////////////////
// get size of Database for restore
// PARAMETER:
//		 dbname   ---- database's name
// RETURN VALUE: 
//       if success return size of database, otherwise return -1
// AUTOTHOR: sunyh
// VERSION: 1.0        
//////////////////////////////////////////////////////////////////
DWORD CRegistry_DB::GetRestoreDBSize(LPWSTR DBName,PCEGUID pceguid)
{
	CEOIDINFO CeObjectInfo;
	CEDBASEINFO infDatabase;
	CEOID dbceoid=0;
	HANDLE hdb;
	hdb=CeOpenDatabaseEx(pceguid,&dbceoid,DBName,0,0,NULL); 
	DWORD dbsize = 0;
	if(hdb==NULL)
		return -1;
	CloseHandle(hdb);
	//get the database info in the mounted volume
	if(CeOidGetInfoEx(pceguid,dbceoid,&CeObjectInfo))
	{
		infDatabase = CeObjectInfo.infDatabase;
		dbsize = infDatabase.dwSize;
	}
	dbceoid=0;
	return dbsize;
}

//////////////////////////////////////////////////////////////////
// get all Database information for restore
// PARAMETER:
//		 pceguid  ---- PCEGUID for volume
// RETURN VALUE: 
//       True if success, otherwise False
// AUTOTHOR: sunyh
// VERSION: 1.0        
//////////////////////////////////////////////////////////////////

BOOL CRegistry_DB::GetTotalRestoreDB(PCEGUID pceguid)
{
	CEOID dbceoid=0;	
	BackupItem DBItem;
	HANDLE hMountedDB;
	CEOID dboid;
	hMountedDB=CeFindFirstDatabaseEx(pceguid,0);
	dboid=CeFindNextDatabaseEx(hMountedDB,pceguid);
	CEOIDINFO poidInfo;
	if (m_DBItemList.GetCount() >0 )
		m_DBItemList.RemoveAll();
	while(dboid)
	{
		ZeroMemory(&DBItem,sizeof(DBItem));
		CeOidGetInfoEx(pceguid,dboid,&poidInfo);
		wcscpy(DBItem.ItemName,poidInfo.infDatabase.szDbaseName);
		DBItem.ItemSize = GetRestoreDBSize(DBItem.ItemName,pceguid);
		m_DBItemList.AddTail(DBItem);
		dboid=CeFindNextDatabaseEx(hMountedDB,pceguid);
	}
	return TRUE;	
}

BOOL CRegistry_DB::SetKeyFlag(BOOL setFlag)
{
	HKEY hKeyRoot[]={HKEY_LOCAL_MACHINE,HKEY_CLASSES_ROOT,HKEY_CURRENT_USER,HKEY_USERS,0};
	WCHAR    *keyRootName[]={L"HKEY_LOCAL_MACHINE",L"HKEY_CLASSES_ROOT",L"HKEY_CURRENT_USER",L"HKEY_USERS",0};
	CArray<KEYNODE, KEYNODE> keyNode;
	HKEY     *hkRoot=hKeyRoot;
	WCHAR    **krName=keyRootName;

	WCHAR* keyName=new WCHAR[MAX_PATH];
//	UCHAR* valueData=new UCHAR[MAX_DATA_SIZE];
	if (!keyName) 
	{
		CString Msg;
		Msg.LoadString(MSG_NO_MEMO);
		::MessageBox(NULL,Msg,BACKUPTITLE,MB_OK|MB_ICONEXCLAMATION|MB_ICONERROR);
		return false;
	}

	while (*hkRoot) {
		HKEY hKey=*hkRoot;
		KEYNODE kNode;
		kNode.hKey=hKey;
		kNode.nodeIndex=0;
		kNode.depath=0;
		keyNode.Add(kNode);
		while (true) {
			DWORD keyNameLen=MAX_PATH;
			long rt=RegEnumKeyEx(kNode.hKey, kNode.nodeIndex, keyName, &keyNameLen, NULL, NULL, NULL, NULL);
			if (rt==ERROR_SUCCESS) {
				RegOpenKeyEx(kNode.hKey,keyName,NULL,NULL,&hKey);
				kNode.hKey=hKey;
				kNode.nodeIndex=0;
				kNode.depath++;
				keyNode.Add(kNode);
				if (setFlag)
					RegSetValueEx(kNode.hKey,REGFLAG,NULL,REG_NONE,NULL,NULL);
				else
					RegDeleteValue(kNode.hKey, REGFLAG);
				continue;
			}
			int keyNodeEnd=keyNode.GetSize()-1;
			if (keyNodeEnd) RegCloseKey(kNode.hKey);
			keyNode.RemoveAt(keyNodeEnd);
			if (!keyNodeEnd) break;
			kNode=keyNode.GetAt(--keyNodeEnd);
			kNode.nodeIndex++;
			keyNode.RemoveAt(keyNodeEnd);
			keyNode.Add(kNode);
		}
		hkRoot++;
		krName++;
	}
	delete[] keyName;
	return TRUE;
}

BOOL CRegistry_DB::BackKeyNode(CArray<KEYNODE, KEYNODE>& keyNode, CStringList &keyNameList, int depath, bool& isKey, KEYNODE& kNode)
{
	WCHAR keyName[MAX_PATH];
	int count=keyNode.GetSize();
	if (!count) return TRUE;
	while(count--) {
		kNode=keyNode.GetAt(count);
		if (kNode.depath==depath) break;	// if key, depath decrease one in parameter;
		// delete value;
		if (isKey) {
			int vIndex=0;
			DWORD keyNameLen=MAX_PATH;
			while (RegEnumValue(kNode.hKey, vIndex++, keyName, &keyNameLen, NULL, NULL,NULL,NULL)==ERROR_SUCCESS) {
				keyNameList.AddTail(keyName);
				keyNameLen=MAX_PATH;
			}
		} else {
			isKey=TRUE;
		}
		while (!keyNameList.IsEmpty()) {
			CString cs=keyNameList.GetTail();
			RegDeleteValue(kNode.hKey,cs.GetBuffer(0));
			keyNameList.RemoveTail();
		}
		//
		RegCloseKey(kNode.hKey);
		keyNode.RemoveAt(count);
	}
	if (count==-1) {
		CString Msg;
		Msg.LoadString(MSG_UNKNOWN_ERROR);
		::MessageBox(NULL,Msg,BACKUPTITLE,MB_OK|MB_ICONEXCLAMATION|MB_ICONERROR);
		return FALSE;
	}
	return TRUE;
}

void CRegistry_DB::DeleteKey()
{
	CArray<KEYNODE, KEYNODE> keyNode;
	HKEY     hKeyRoot[]={HKEY_LOCAL_MACHINE,HKEY_CLASSES_ROOT,HKEY_CURRENT_USER,HKEY_USERS,0};
	WCHAR    *keyRootName[]={L"HKEY_LOCAL_MACHINE",L"HKEY_CLASSES_ROOT",L"HKEY_CURRENT_USER",L"HKEY_USERS",0};
	HKEY     *hkRoot=hKeyRoot;
	WCHAR    **krName=keyRootName;

	WCHAR* keyName=new WCHAR[MAX_PATH];
	if (!keyName) {
		CString Msg;
		Msg.LoadString(MSG_UNKNOWN_ERROR);
		::MessageBox(NULL,Msg,BACKUPTITLE,MB_OK|MB_ICONEXCLAMATION|MB_ICONERROR);
		return;
	}

	while (*hkRoot) {
		HKEY hKey=*hkRoot;
		KEYNODE kNode;
		kNode.hKey=hKey;
		kNode.nodeIndex=0;
		kNode.depath=0;
		keyNode.Add(kNode);
		while (true) {
			DWORD keyNameLen=MAX_PATH;
			if (RegEnumKeyEx(kNode.hKey, kNode.nodeIndex,
							keyName, &keyNameLen,
							NULL, NULL, NULL, NULL)==ERROR_SUCCESS) {
				RegOpenKeyEx(kNode.hKey,keyName,NULL,NULL,&hKey);
				if (RegQueryValueEx(hKey,REGFLAG,NULL,NULL,NULL,NULL)==ERROR_SUCCESS) {
					RegCloseKey(hKey);
					DeleteKeyRecursive(kNode.hKey,keyName);
				} else {
					kNode.hKey=hKey;
					kNode.nodeIndex=0;
					kNode.depath++;
					keyNode.Add(kNode);
				}
				continue;
			}
			int keyNodeEnd=keyNode.GetSize()-1;
			if (keyNodeEnd) RegCloseKey(kNode.hKey);
			keyNode.RemoveAt(keyNodeEnd);
			if (!keyNodeEnd) break;
			kNode=keyNode.GetAt(--keyNodeEnd);
			kNode.nodeIndex++;
			keyNode.RemoveAt(keyNodeEnd);
			keyNode.Add(kNode);
		}
		hkRoot++;
		krName++;
	}
	delete[] keyName;

}

void CRegistry_DB::DeleteKeyRecursive(HKEY hKey, LPCWSTR lpSubKey)
{
	WCHAR* keyName=new WCHAR[MAX_PATH];
	HKEY hk;
	RegOpenKeyEx(hKey,lpSubKey,NULL,NULL,&hk);
	DWORD keyNameLen=MAX_PATH;
	while (RegEnumKeyEx(hk, 0, keyName, &keyNameLen, NULL, NULL, NULL, NULL)==ERROR_SUCCESS) {
		DeleteKeyRecursive(hk, keyName);
	}
	RegCloseKey(hk);
	RegDeleteKey(hKey, lpSubKey);
}

DWORD CRegistry_DB::GetBackupRegistrySize()
{
	UINT regSize=0;
	HKEY hKeyRoot[] = {HKEY_LOCAL_MACHINE,HKEY_CLASSES_ROOT,HKEY_CURRENT_USER,HKEY_USERS,0};
	WCHAR    *keyRootName[] = {L"HKEY_LOCAL_MACHINE",L"HKEY_CLASSES_ROOT",L"HKEY_CURRENT_USER",L"HKEY_USERS",0};
	// array contains all keys
	CArray<KEYNODE, KEYNODE> keyNode;
	HKEY     *hkRoot;
	WCHAR    **krName;
	hkRoot = hKeyRoot;
	krName = keyRootName;

	WCHAR* keyName = new WCHAR[MAX_PATH];
	UCHAR* valueData = new UCHAR[MAX_DATA_SIZE];
	if (!keyName || !valueData) 
	{
		CString Msg;
		Msg.LoadString(MSG_NO_MEMO);
		::MessageBox(NULL,Msg,BACKUPTITLE,MB_OK|MB_ICONEXCLAMATION|MB_ICONERROR);
		return -1;
	}
	DWORD keyNameLen = 0;
	LONG rt = 0;
	int vIndex = 0;
	DWORD valueDataLen = 0, valueType = 0;
	while (*hkRoot) 
	{
		HKEY hKey = *hkRoot;
		regSize += REGVALUESIZE+wcslen(*krName)*sizeof(WCHAR);
		KEYNODE kNode;
		kNode.hKey=hKey;
		kNode.nodeIndex=0;
		kNode.depath=0;
		keyNode.Add(kNode);
		while (1) 
		{
			keyNameLen=MAX_PATH;
			rt=RegEnumKeyEx(kNode.hKey, kNode.nodeIndex, keyName, &keyNameLen, NULL, NULL, NULL, NULL);
			//if this key has subkey, add it to array
			if (rt==ERROR_SUCCESS) 
			{
				RegOpenKeyEx(kNode.hKey,keyName,NULL,NULL,&hKey);
				kNode.hKey = hKey;
				kNode.nodeIndex = 0;
				kNode.depath++;
				keyNode.Add(kNode);
				regSize += REGVALUESIZE+keyNameLen*sizeof(WCHAR);
				continue;
			}
			vIndex = 0;
			valueDataLen = MAX_DATA_SIZE;
			keyNameLen = MAX_PATH;
			// count the value of keys
			while (RegEnumValue(kNode.hKey, vIndex++, keyName, &keyNameLen, NULL, &valueType, valueData, &valueDataLen) == ERROR_SUCCESS) 
			{
				regSize+=REGVALUESIZE+valueDataLen+keyNameLen*sizeof(WCHAR);
				valueDataLen = MAX_DATA_SIZE;
				keyNameLen = MAX_PATH;
			}
			int keyNodeEnd = keyNode.GetSize()-1;
			if (keyNodeEnd) 
				RegCloseKey(kNode.hKey);
			keyNode.RemoveAt(keyNodeEnd);
			if (!keyNodeEnd) 
				break;
			kNode = keyNode.GetAt(--keyNodeEnd);
			kNode.nodeIndex++;
			keyNode.RemoveAt(keyNodeEnd);
			keyNode.Add(kNode);
		}
		hkRoot++;
		krName++;
	}
	delete[] keyName;
	delete[] valueData;
	return regSize;
}
//////////////////////////////////////////////////////////////////
// get all Database information for backup
// RETURN VALUE: 
//       True if success, otherwise False
// AUTOTHOR: sunyh
// VERSION: 1.0        
//////////////////////////////////////////////////////////////////


BOOL CRegistry_DB::GetTotalBackupDB()
{	
	CEOID ceoid;
	if (m_DBItemList.GetCount() >0 )
		m_DBItemList.RemoveAll();
	BackupItem item;
	ZeroMemory(&item,sizeof(item));

	HANDLE dbHandle;
	CEOIDINFO CeObjectInfo;
	HANDLE FindDBhandle = CeFindFirstDatabase(0);
	if (FindDBhandle == INVALID_HANDLE_VALUE)
		return TRUE;
	else
	{
		while (ceoid = CeFindNextDatabase(FindDBhandle))
		{
			dbHandle = CeOpenDatabase(&ceoid,NULL,0,0,NULL);
			if (dbHandle == INVALID_HANDLE_VALUE)
				continue;			
			if(!CeOidGetInfo(ceoid,&CeObjectInfo))
				return FALSE;
			wcscpy(item.ItemName,CeObjectInfo.infDatabase.szDbaseName);
			item.ItemSize = CeObjectInfo.infDatabase.dwSize;
			m_DBItemList.AddTail(item);
			CloseHandle(dbHandle);
		}
	}
/*	CCeDBEnum dbEnum;
	CCeDBDatabase db;
	while(ceoid=dbEnum.Next())
	{
		if(!db.Open(ceoid))
			continue;
		db.GetName(szName);
		item.ItemSize = db.GetSize();
		wcscpy(item.ItemName,szName);
		m_DBItemList.AddTail(item);
		db.Close();
	}
*/	return TRUE;
}

void CRegistry_DB::SetProgressWnd(CProgressDlg *pProgressWnd)
{
	m_pProgressWnd = pProgressWnd;
}