INT_PTR CALLBACK UserIdDialogProcedure(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
static char *keyid;
HWND hLV = GetDlgItem(hdlg,IDC_KEYLIST);
switch(msg)
{
case WM_INITDIALOG:
{
int i;
LVCOLUMN lvc;
static char *szColHdr[] = { "Key ID", "User ID" };
static int iColWidth[] = { 110, 255 };
keyid = (char *)lparam;
ZeroMemory(&lvc,sizeof(LVCOLUMN));
lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
lvc.fmt = LVCFMT_LEFT;
for (i = 0; i < 2; i++) {
lvc.iSubItem = i;
lvc.pszText = szColHdr[i];
lvc.cx = iColWidth[i];
ListView_InsertColumn(hLV, i, &lvc);
}
RefreshListView(hLV);
ListView_SetExtendedListViewStyle(hLV, ListView_GetExtendedListViewStyle(hLV) | LVS_EX_FULLROWSELECT);
ListView_SetItemState(hLV, 0, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
EnableWindow(hLV, TRUE);
}
break;
case WM_COMMAND:
switch(LOWORD(wparam))
{
case IDOK:
ListView_GetItemText(hLV, ListView_GetNextItem(hLV, -1, LVNI_SELECTED), 0, keyid, keyidsize);
case IDCANCEL:
EndDialog(hdlg, wparam);
return TRUE;
break;
case IDC_REFRESH:
updateKeyUserIDs(publickeyuserid);
updateKeyUserIDs(secretkeyuserid);
RefreshListView(hLV);
break;
}
break;
}
return FALSE;
}
static BOOL UnloadHive(HWND hWnd)
{
TCHAR Caption[128];
LPCTSTR pszKeyPath;
HKEY hRootKey;
LONG regUnloadResult;
/* get the item key to unload */
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
/* load and set the caption and flags for dialog */
LoadString(hInst, IDS_UNLOAD_HIVE, Caption, COUNT_OF(Caption));
/* now unload the hive */
regUnloadResult = RegUnLoadKey(hRootKey, pszKeyPath);
if(regUnloadResult == ERROR_SUCCESS)
{
/* refresh tree and list views */
RefreshTreeView(g_pChildWnd->hTreeWnd);
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
}
else
{
ErrorMessageBox(hWnd, Caption, regUnloadResult);
return FALSE;
}
return TRUE;
}
static BOOL UnloadHive(HWND hWnd)
{
WCHAR Caption[128];
LPCWSTR pszKeyPath;
HKEY hRootKey;
LONG regUnloadResult;
/* get the item key to unload */
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
/* load and set the caption and flags for dialog */
LoadStringW(hInst, IDS_UNLOAD_HIVE, Caption, COUNT_OF(Caption));
/* Enable the 'restore' privilege, unload the hive, disable the privilege */
EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);
regUnloadResult = RegUnLoadKeyW(hRootKey, pszKeyPath);
EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);
if(regUnloadResult == ERROR_SUCCESS)
{
/* refresh tree and list views */
RefreshTreeView(g_pChildWnd->hTreeWnd);
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
}
else
{
ErrorMessageBox(hWnd, Caption, regUnloadResult);
return FALSE;
}
return TRUE;
}
static BOOL LoadHive(HWND hWnd)
{
OPENFILENAME ofn;
WCHAR Caption[128];
LPCWSTR pszKeyPath;
WCHAR xPath[LOADHIVE_KEYNAMELENGTH];
HKEY hRootKey;
WCHAR Filter[1024];
FILTERPAIR filter;
/* get the item key to load the hive in */
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
/* initialize the "open file" dialog */
InitOpenFileName(hWnd, &ofn);
/* build the "All Files" filter up */
filter.DisplayID = IDS_FLT_ALLFILES;
filter.FilterID = IDS_FLT_ALLFILES_FLT;
BuildFilterStrings(Filter, &filter, 1);
ofn.lpstrFilter = Filter;
/* load and set the caption and flags for dialog */
LoadStringW(hInst, IDS_LOAD_HIVE, Caption, COUNT_OF(Caption));
ofn.lpstrTitle = Caption;
ofn.Flags |= OFN_ENABLESIZING;
/* ofn.lCustData = ;*/
/* now load the hive */
if (GetOpenFileName(&ofn))
{
if (DialogBoxParamW(hInst, MAKEINTRESOURCEW(IDD_LOADHIVE), hWnd,
&LoadHive_KeyNameInHookProc, (LPARAM)xPath))
{
LONG regLoadResult;
/* Enable the 'restore' privilege, load the hive, disable the privilege */
EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);
regLoadResult = RegLoadKeyW(hRootKey, xPath, ofn.lpstrFile);
EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);
if(regLoadResult == ERROR_SUCCESS)
{
/* refresh tree and list views */
RefreshTreeView(g_pChildWnd->hTreeWnd);
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
}
else
{
ErrorMessageBox(hWnd, Caption, regLoadResult);
return FALSE;
}
}
}
else
{
CheckCommDlgError(hWnd);
}
return TRUE;
}
static void OnTreeSelectionChanged(HWND hwndTV, HWND hwndLV, HTREEITEM hItem, BOOL bRefreshLV)
{
if (bRefreshLV) {
LPWSTR keyPath;
HKEY hRootKey = NULL;
keyPath = GetItemPath(hwndTV, hItem, &hRootKey);
RefreshListView(hwndLV, hRootKey, keyPath, NULL);
HeapFree(GetProcessHeap(), 0, keyPath);
}
UpdateStatusBar();
}
void MainWindow::OnDropFiles (HWND hWnd, WPARAM wParam, LPARAM lParam)
{
int iCount = DragQueryFile ((HDROP) wParam, 0xFFFFFFFF, NULL, NULL);
int i = 0;
int r = 0;
char szFilepath[SIZE_STRING];
char szCurfilepath[SIZE_STRING];
m_wndenc.ClearFileInfo (); // Clear any existing file info objects from the encryption window
DynList dlAllfiles;
m_pdiag->OutputInt ("Number of dropped files: ", iCount);
for (i=0;i<iCount;i++) {
ZeroMemory (szFilepath, SIZE_STRING);
DragQueryFile ((HDROP) wParam, i, szFilepath, SIZE_STRING);
if (m_Dirscanner.IsFolder (szFilepath) == true) {
m_pdiag->OutputText ("DropPath: FOLDER: ", szFilepath);
dlAllfiles.Clear ();
m_Dirscanner.ListAllFiles (szFilepath, &dlAllfiles);
// Now list out all the recursively scanned files
for (r=0;r<dlAllfiles.GetNumItems ();r++) {
ZeroMemory (szCurfilepath, SIZE_STRING);
strcpy_s (szCurfilepath, SIZE_STRING, (char *) dlAllfiles.GetItem (r));
m_pdiag->OutputText ("ScannedFile: ", szCurfilepath);
// Add the item to the encryption window list
m_wndenc.AddFileInfo (szCurfilepath, szFilepath, true);
}
} else {
m_pdiag->OutputText ("DropPath: FILE: ", szFilepath);
// Add the item to the encryption window list
m_wndenc.AddFileInfo (szFilepath, false);
}
}
dlAllfiles.Clear ();
m_wndenc.DoEncryption (m_szCurrentfolder);
RefreshListView (m_szCurrentfolder);
}
static VOID
UpdateAddress(HTREEITEM hItem, HKEY hRootKey, LPCWSTR pszPath)
{
LPCWSTR keyPath, rootName;
LPWSTR fullPath;
if (pszPath == NULL)
keyPath = GetItemPath(g_pChildWnd->hTreeWnd, hItem, &hRootKey);
else
keyPath = pszPath;
if (keyPath)
{
RefreshListView(g_pChildWnd->hListWnd, hRootKey, keyPath);
rootName = get_root_key_name(hRootKey);
fullPath = HeapAlloc(GetProcessHeap(), 0, (wcslen(rootName) + 1 + wcslen(keyPath) + 1) * sizeof(WCHAR));
if (fullPath)
{
/* set (correct) the address bar text */
if (keyPath[0] != L'\0')
swprintf(fullPath, L"%s\\%s", rootName, keyPath);
else
fullPath = wcscpy(fullPath, rootName);
SendMessageW(hStatusBar, SB_SETTEXTW, 0, (LPARAM)fullPath);
SendMessageW(g_pChildWnd->hAddressBarWnd, WM_SETTEXT, 0, (LPARAM)fullPath);
HeapFree(GetProcessHeap(), 0, fullPath);
/* disable hive manipulation items temporarily (enable only if necessary) */
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_LOADHIVE, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_UNLOADHIVE, MF_BYCOMMAND | MF_GRAYED);
/* compare the strings to see if we should enable/disable the "Load Hive" menus accordingly */
if (!(_wcsicmp(rootName, L"HKEY_LOCAL_MACHINE") &&
_wcsicmp(rootName, L"HKEY_USERS")))
{
/*
* enable the unload menu item if at the root, otherwise
* enable the load menu item if there is no slash in
* keyPath (ie. immediate child selected)
*/
if(keyPath[0] == L'\0')
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_LOADHIVE, MF_BYCOMMAND | MF_ENABLED);
else if(!wcschr(keyPath, L'\\'))
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_UNLOADHIVE, MF_BYCOMMAND | MF_ENABLED);
}
}
}
}
static BOOL ImportRegistryFile(HWND hWnd)
{
OPENFILENAME ofn;
TCHAR Caption[128], szTitle[256], szText[256];
LPCTSTR pszKeyPath;
HKEY hRootKey;
InitOpenFileName(hWnd, &ofn);
LoadString(hInst, IDS_IMPORT_REG_FILE, Caption, COUNT_OF(Caption));
ofn.lpstrTitle = Caption;
ofn.Flags |= OFN_ENABLESIZING;
/* ofn.lCustData = ;*/
if (GetOpenFileName(&ofn))
{
FILE *fp = _wfopen(ofn.lpstrFile, L"r");
if (fp == NULL || !import_registry_file(fp))
{
LPSTR p = GetMultiByteString(ofn.lpstrFile);
fprintf(stderr, "Can't open file \"%s\"\n", p);
HeapFree(GetProcessHeap(), 0, p);
if (fp != NULL)
fclose(fp);
return FALSE;
}
LoadString(hInst, IDS_APP_TITLE, szTitle, sizeof(szTitle));
LoadString(hInst, IDS_IMPORTED_OK, szText, sizeof(szTitle));
/* show successful import */
MessageBox(NULL, szText, szTitle, MB_OK);
fclose(fp);
}
else
{
CheckCommDlgError(hWnd);
}
RefreshTreeView(g_pChildWnd->hTreeWnd);
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
return TRUE;
}
/*******************************************************************************
*
* FUNCTION: _CmdWndProc(HWND, unsigned, WORD, LONG)
*
* PURPOSE: Processes WM_COMMAND messages for the main frame window.
*
*/
static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
HKEY hKeyRoot = 0, hKey = 0;
LPCTSTR keyPath;
LPCTSTR valueName;
BOOL result = TRUE;
REGSAM regsam = KEY_READ;
LONG lRet;
int item;
UNREFERENCED_PARAMETER(lParam);
UNREFERENCED_PARAMETER(message);
switch (LOWORD(wParam))
{
case ID_REGISTRY_LOADHIVE:
LoadHive(hWnd);
return TRUE;
case ID_REGISTRY_UNLOADHIVE:
UnloadHive(hWnd);
return TRUE;
case ID_REGISTRY_IMPORTREGISTRYFILE:
ImportRegistryFile(hWnd);
return TRUE;
case ID_REGISTRY_EXPORTREGISTRYFILE:
ExportRegistryFile(hWnd);
return TRUE;
case ID_REGISTRY_CONNECTNETWORKREGISTRY:
{
IDsObjectPicker *ObjectPicker;
TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
HRESULT hRet;
hRet = CoInitialize(NULL);
if (SUCCEEDED(hRet))
{
hRet = InitializeRemoteRegistryPicker(&ObjectPicker);
if (SUCCEEDED(hRet))
{
hRet = InvokeRemoteRegistryPickerDialog(ObjectPicker,
hWnd,
szComputerName,
sizeof(szComputerName) / sizeof(szComputerName[0]));
if (hRet == S_OK)
{
/* FIXME - connect to the registry */
}
FreeObjectPicker(ObjectPicker);
}
CoUninitialize();
}
return TRUE;
}
case ID_REGISTRY_DISCONNECTNETWORKREGISTRY:
return TRUE;
case ID_REGISTRY_PRINT:
PrintRegistryHive(hWnd, _T(""));
return TRUE;
case ID_REGISTRY_EXIT:
DestroyWindow(hWnd);
return TRUE;
case ID_VIEW_STATUSBAR:
toggle_child(hWnd, LOWORD(wParam), hStatusBar);
return TRUE;
case ID_HELP_HELPTOPICS:
WinHelp(hWnd, _T("regedit"), HELP_FINDER, 0);
return TRUE;
case ID_HELP_ABOUT:
ShowAboutBox(hWnd);
return TRUE;
case ID_VIEW_SPLIT:
{
RECT rt;
POINT pt, pts;
GetClientRect(g_pChildWnd->hWnd, &rt);
pt.x = rt.left + g_pChildWnd->nSplitPos;
pt.y = (rt.bottom / 2);
pts = pt;
if(ClientToScreen(g_pChildWnd->hWnd, &pts))
{
SetCursorPos(pts.x, pts.y);
SetCursor(LoadCursor(0, IDC_SIZEWE));
SendMessage(g_pChildWnd->hWnd, WM_LBUTTONDOWN, 0, MAKELPARAM(pt.x, pt.y));
}
return TRUE;
}
case ID_EDIT_RENAME:
case ID_EDIT_MODIFY:
case ID_EDIT_MODIFY_BIN:
case ID_EDIT_DELETE:
regsam |= KEY_WRITE;
break;
}
keyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
valueName = GetValueName(g_pChildWnd->hListWnd, -1);
if (keyPath)
{
lRet = RegOpenKeyEx(hKeyRoot, keyPath, 0, regsam, &hKey);
if (lRet != ERROR_SUCCESS) hKey = 0;
}
switch (LOWORD(wParam))
{
case ID_EDIT_MODIFY:
if (valueName && ModifyValue(hWnd, hKey, valueName, FALSE))
RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
break;
case ID_EDIT_MODIFY_BIN:
if (valueName && ModifyValue(hWnd, hKey, valueName, TRUE))
RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
break;
case ID_EDIT_RENAME:
if (GetFocus() == g_pChildWnd->hListWnd)
{
if(ListView_GetSelectedCount(g_pChildWnd->hListWnd) == 1)
{
item = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_SELECTED);
if(item > -1)
{
(void)ListView_EditLabel(g_pChildWnd->hListWnd, item);
}
}
}
else if (GetFocus() == g_pChildWnd->hTreeWnd)
{
/* Get focused entry of treeview (if any) */
HTREEITEM hItem = TreeView_GetSelection(g_pChildWnd->hTreeWnd);
if (hItem != NULL)
(void)TreeView_EditLabel(g_pChildWnd->hTreeWnd, hItem);
}
break;
case ID_EDIT_DELETE:
{
if (GetFocus() == g_pChildWnd->hListWnd)
{
UINT nSelected = ListView_GetSelectedCount(g_pChildWnd->hListWnd);
if(nSelected >= 1)
{
TCHAR msg[128], caption[128];
LoadString(hInst, IDS_QUERY_DELETE_CONFIRM, caption, sizeof(caption)/sizeof(TCHAR));
LoadString(hInst, (nSelected == 1 ? IDS_QUERY_DELETE_ONE : IDS_QUERY_DELETE_MORE), msg, sizeof(msg)/sizeof(TCHAR));
if(MessageBox(g_pChildWnd->hWnd, msg, caption, MB_ICONQUESTION | MB_YESNO) == IDYES)
{
int ni, errs;
item = -1;
errs = 0;
while((ni = ListView_GetNextItem(g_pChildWnd->hListWnd, item, LVNI_SELECTED)) > -1)
{
valueName = GetValueName(g_pChildWnd->hListWnd, item);
if(RegDeleteValue(hKey, valueName) != ERROR_SUCCESS)
{
errs++;
}
item = ni;
}
RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
if(errs > 0)
{
LoadString(hInst, IDS_ERR_DELVAL_CAPTION, caption, sizeof(caption)/sizeof(TCHAR));
LoadString(hInst, IDS_ERR_DELETEVALUE, msg, sizeof(msg)/sizeof(TCHAR));
MessageBox(g_pChildWnd->hWnd, msg, caption, MB_ICONSTOP);
}
}
}
}
else if (GetFocus() == g_pChildWnd->hTreeWnd)
{
if (keyPath == 0 || *keyPath == 0)
{
MessageBeep(MB_ICONHAND);
}
else if (DeleteKey(hWnd, hKeyRoot, keyPath))
{
DeleteNode(g_pChildWnd->hTreeWnd, 0);
RefreshTreeView(g_pChildWnd->hTreeWnd);
}
}
break;
}
case ID_EDIT_NEW_STRINGVALUE:
CreateNewValue(hKeyRoot, keyPath, REG_SZ);
break;
case ID_EDIT_NEW_BINARYVALUE:
CreateNewValue(hKeyRoot, keyPath, REG_BINARY);
break;
case ID_EDIT_NEW_DWORDVALUE:
CreateNewValue(hKeyRoot, keyPath, REG_DWORD);
break;
case ID_EDIT_NEW_MULTISTRINGVALUE:
CreateNewValue(hKeyRoot, keyPath, REG_MULTI_SZ);
break;
case ID_EDIT_NEW_EXPANDABLESTRINGVALUE:
CreateNewValue(hKeyRoot, keyPath, REG_EXPAND_SZ);
break;
case ID_EDIT_FIND:
FindDialog(hWnd);
break;
case ID_EDIT_FINDNEXT:
FindNext(hWnd);
break;
case ID_EDIT_COPYKEYNAME:
CopyKeyName(hWnd, hKeyRoot, keyPath);
break;
case ID_EDIT_PERMISSIONS:
RegKeyEditPermissions(hWnd, hKeyRoot, NULL, keyPath);
break;
case ID_REGISTRY_PRINTERSETUP:
/*PRINTDLG pd;*/
/*PrintDlg(&pd);*/
/*PAGESETUPDLG psd;*/
/*PageSetupDlg(&psd);*/
break;
case ID_REGISTRY_OPENLOCAL:
break;
case ID_VIEW_REFRESH:
RefreshTreeView(g_pChildWnd->hTreeWnd);
/*RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, NULL); */
break;
/*case ID_OPTIONS_TOOLBAR:*/
/* toggle_child(hWnd, LOWORD(wParam), hToolBar);*/
/* break;*/
case ID_EDIT_NEW_KEY:
CreateNewKey(g_pChildWnd->hTreeWnd, TreeView_GetSelection(g_pChildWnd->hTreeWnd));
break;
default:
if ((LOWORD(wParam) >= ID_FAVORITES_MIN) && (LOWORD(wParam) <= ID_FAVORITES_MAX))
{
HMENU hMenu;
MENUITEMINFO mii;
TCHAR szFavorite[512];
hMenu = GetSubMenu(GetMenu(hWnd), FAVORITES_MENU_POSITION);
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_TYPE;
mii.fType = MFT_STRING;
mii.dwTypeData = szFavorite;
mii.cch = sizeof(szFavorite) / sizeof(szFavorite[0]);
if (GetMenuItemInfo(hMenu, LOWORD(wParam) - ID_FAVORITES_MIN, TRUE, &mii))
{
ChooseFavorite(szFavorite);
}
}
else
{
result = FALSE;
}
break;
}
if(hKey)
RegCloseKey(hKey);
return result;
}
static BOOL CreateNewValue(HKEY hRootKey, LPCTSTR pszKeyPath, DWORD dwType)
{
TCHAR szNewValueFormat[128];
TCHAR szNewValue[128];
int iIndex = 1;
BYTE data[128];
DWORD dwExistingType, cbData;
LONG lResult;
HKEY hKey;
LVFINDINFO lvfi;
if (RegOpenKeyEx(hRootKey, pszKeyPath, 0, KEY_QUERY_VALUE | KEY_SET_VALUE,
&hKey) != ERROR_SUCCESS)
return FALSE;
LoadString(hInst, IDS_NEW_VALUE, szNewValueFormat, COUNT_OF(szNewValueFormat));
do
{
wsprintf(szNewValue, szNewValueFormat, iIndex++);
cbData = sizeof(data);
lResult = RegQueryValueEx(hKey, szNewValue, NULL, &dwExistingType, data, &cbData);
}
while(lResult == ERROR_SUCCESS);
switch(dwType)
{
case REG_DWORD:
cbData = sizeof(DWORD);
break;
case REG_SZ:
case REG_EXPAND_SZ:
cbData = sizeof(TCHAR);
break;
case REG_MULTI_SZ:
cbData = sizeof(TCHAR) * 2;
break;
case REG_QWORD:
cbData = sizeof(DWORD) * 2;
break;
default:
cbData = 0;
break;
}
memset(data, 0, cbData);
lResult = RegSetValueEx(hKey, szNewValue, 0, dwType, data, cbData);
RegCloseKey(hKey);
if (lResult != ERROR_SUCCESS)
{
return FALSE;
}
RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
/* locate the newly added value, and get ready to rename it */
memset(&lvfi, 0, sizeof(lvfi));
lvfi.flags = LVFI_STRING;
lvfi.psz = szNewValue;
iIndex = ListView_FindItem(g_pChildWnd->hListWnd, -1, &lvfi);
if (iIndex >= 0)
(void)ListView_EditLabel(g_pChildWnd->hListWnd, iIndex);
return TRUE;
}
static BOOL CreateNewValue(HKEY hRootKey, LPCWSTR pszKeyPath, DWORD dwType)
{
WCHAR szNewValueFormat[128];
WCHAR szNewValue[128];
int iIndex = 1;
BYTE data[128];
DWORD dwExistingType, cbData;
LONG lResult;
HKEY hKey;
LVFINDINFO lvfi;
if (RegOpenKeyExW(hRootKey, pszKeyPath, 0, KEY_QUERY_VALUE | KEY_SET_VALUE,
&hKey) != ERROR_SUCCESS)
return FALSE;
LoadStringW(hInst, IDS_NEW_VALUE, szNewValueFormat, COUNT_OF(szNewValueFormat));
do
{
wsprintf(szNewValue, szNewValueFormat, iIndex++);
cbData = sizeof(data);
lResult = RegQueryValueExW(hKey, szNewValue, NULL, &dwExistingType, data, &cbData);
}
while(lResult == ERROR_SUCCESS);
switch(dwType)
{
case REG_DWORD:
cbData = sizeof(DWORD);
break;
case REG_SZ:
case REG_EXPAND_SZ:
cbData = sizeof(WCHAR);
break;
case REG_MULTI_SZ:
/*
* WARNING: An empty multi-string has only one null char.
* Indeed, multi-strings are built in the following form:
* str1\0str2\0...strN\0\0
* where each strI\0 is a null-terminated string, and it
* ends with a terminating empty string.
* Therefore an empty multi-string contains only the terminating
* empty string, that is, one null char.
*/
cbData = sizeof(WCHAR);
break;
case REG_QWORD: /* REG_QWORD_LITTLE_ENDIAN */
cbData = sizeof(DWORDLONG); // == sizeof(DWORD) * 2;
break;
default:
cbData = 0;
break;
}
memset(data, 0, cbData);
lResult = RegSetValueExW(hKey, szNewValue, 0, dwType, data, cbData);
RegCloseKey(hKey);
if (lResult != ERROR_SUCCESS)
{
return FALSE;
}
RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
/* locate the newly added value, and get ready to rename it */
memset(&lvfi, 0, sizeof(lvfi));
lvfi.flags = LVFI_STRING;
lvfi.psz = szNewValue;
iIndex = ListView_FindItem(g_pChildWnd->hListWnd, -1, &lvfi);
if (iIndex >= 0)
(void)ListView_EditLabel(g_pChildWnd->hListWnd, iIndex);
return TRUE;
}
static BOOL ImportRegistryFile(HWND hWnd)
{
BOOL bRet = FALSE;
OPENFILENAME ofn;
WCHAR Caption[128], szTitle[512], szText[512];
HKEY hKeyRoot;
LPCWSTR pszKeyPath;
/* Figure out in which key path we are importing */
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
InitOpenFileName(hWnd, &ofn);
LoadStringW(hInst, IDS_IMPORT_REG_FILE, Caption, COUNT_OF(Caption));
ofn.lpstrTitle = Caption;
ofn.Flags |= OFN_ENABLESIZING;
/* ofn.lCustData = ;*/
if (GetOpenFileName(&ofn))
{
/* Look at the extension of the file to determine its type */
if (ofn.nFileExtension >= 1 &&
_wcsicmp(ofn.lpstrFile + ofn.nFileExtension, L"reg") == 0) /* REGEDIT4 or Windows Registry Editor Version 5.00 */
{
/* Open the file */
FILE* fp = _wfopen(ofn.lpstrFile, L"r");
/* Import it */
if (fp == NULL || !import_registry_file(fp))
{
/* Error opening the file */
LoadStringW(hInst, IDS_APP_TITLE, szTitle, COUNT_OF(szTitle));
LoadStringW(hInst, IDS_IMPORT_ERROR, szText, COUNT_OF(szText));
InfoMessageBox(hWnd, MB_OK | MB_ICONERROR, szTitle, szText, ofn.lpstrFile);
bRet = FALSE;
}
else
{
/* Show successful import */
LoadStringW(hInst, IDS_APP_TITLE, szTitle, COUNT_OF(szTitle));
LoadStringW(hInst, IDS_IMPORT_OK, szText, COUNT_OF(szText));
InfoMessageBox(hWnd, MB_OK | MB_ICONINFORMATION, szTitle, szText, ofn.lpstrFile);
bRet = TRUE;
}
/* Close the file */
if (fp) fclose(fp);
}
else /* Registry Hive Files */
{
LoadStringW(hInst, IDS_QUERY_IMPORT_HIVE_CAPTION, szTitle, COUNT_OF(szTitle));
LoadStringW(hInst, IDS_QUERY_IMPORT_HIVE_MSG, szText, COUNT_OF(szText));
/* Display a confirmation message */
if (MessageBoxW(g_pChildWnd->hWnd, szText, szTitle, MB_ICONWARNING | MB_YESNO) == IDYES)
{
LONG lResult;
HKEY hSubKey;
/* Open the subkey */
lResult = RegOpenKeyExW(hKeyRoot, pszKeyPath, 0, KEY_WRITE, &hSubKey);
if (lResult == ERROR_SUCCESS)
{
/* Enable the 'restore' privilege, restore the hive then disable the privilege */
EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);
lResult = RegRestoreKey(hSubKey, ofn.lpstrFile, REG_FORCE_RESTORE);
EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);
/* Flush the subkey and close it */
RegFlushKey(hSubKey);
RegCloseKey(hSubKey);
}
/* Set the return value */
bRet = (lResult == ERROR_SUCCESS);
/* Display error, if any */
if (!bRet) ErrorMessageBox(hWnd, Caption, lResult);
}
}
}
else
{
CheckCommDlgError(hWnd);
}
/* refresh tree and list views */
RefreshTreeView(g_pChildWnd->hTreeWnd);
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, pszKeyPath);
return bRet;
}
