VOID
SaveProtocol(VOID)
{
HANDLE hEventLog;
WCHAR szFileName[MAX_PATH];
ZeroMemory(szFileName, sizeof(szFileName));
sfn.lpstrFile = szFileName;
sfn.nMaxFile = MAX_PATH;
if (!GetSaveFileNameW(&sfn))
{
return;
}
hEventLog = OpenEventLogW(lpComputerName, lpSourceLogName);
if (!hEventLog)
{
ShowLastWin32Error();
return;
}
if (!BackupEventLogW(hEventLog, szFileName))
{
ShowLastWin32Error();
}
CloseEventLog(hEventLog);
}
BOOL
ClearEvents(VOID)
{
HANDLE hEventLog;
WCHAR szFileName[MAX_PATH];
WCHAR szMessage[MAX_LOADSTRING];
ZeroMemory(szFileName, sizeof(szFileName));
ZeroMemory(szMessage, sizeof(szMessage));
LoadStringW(hInst, IDS_CLEAREVENTS_MSG, szMessage, MAX_LOADSTRING);
sfn.lpstrFile = szFileName;
sfn.nMaxFile = MAX_PATH;
switch (MessageBoxW(hwndMainWindow, szMessage, szTitle, MB_YESNOCANCEL | MB_ICONINFORMATION))
{
case IDCANCEL:
{
return FALSE;
}
case IDNO:
{
sfn.lpstrFile = NULL;
break;
}
case IDYES:
{
if (!GetSaveFileNameW(&sfn))
{
return FALSE;
}
break;
}
}
hEventLog = OpenEventLogW(lpComputerName, lpSourceLogName);
if (!hEventLog)
{
ShowLastWin32Error();
return FALSE;
}
if (!ClearEventLogW(hEventLog, sfn.lpstrFile))
{
ShowLastWin32Error();
CloseEventLog(hEventLog);
return FALSE;
}
CloseEventLog(hEventLog);
return TRUE;
}
static void SaveClipboardToFile(void)
{
OPENFILENAMEW sfn;
LPWSTR c;
WCHAR szFileName[MAX_PATH];
WCHAR szFilterMask[MAX_STRING_LEN + 10];
ZeroMemory(&szFilterMask, sizeof(szFilterMask));
c = szFilterMask + LoadStringW(Globals.hInstance, STRING_FORMAT_NT, szFilterMask, MAX_STRING_LEN) + 1;
wcscpy(c, L"*.clp");
ZeroMemory(&szFileName, sizeof(szFileName));
ZeroMemory(&sfn, sizeof(sfn));
sfn.lStructSize = sizeof(sfn);
sfn.hwndOwner = Globals.hMainWnd;
sfn.hInstance = Globals.hInstance;
sfn.lpstrFilter = szFilterMask;
sfn.lpstrFile = szFileName;
sfn.nMaxFile = ARRAYSIZE(szFileName);
sfn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
sfn.lpstrDefExt = L"clp";
if (!GetSaveFileNameW(&sfn))
return;
if (!OpenClipboard(Globals.hMainWnd))
{
ShowLastWin32Error(Globals.hMainWnd);
return;
}
WriteClipboardFile(szFileName, CLIP_FMT_NT /* CLIP_FMT_31 */);
CloseClipboard();
}
BOOL
GetEventMessageFileDLL(IN LPCWSTR lpLogName,
IN LPCWSTR SourceName,
IN LPCWSTR EntryName,
OUT PWCHAR ExpandedName)
{
DWORD dwSize;
BYTE szModuleName[MAX_PATH];
WCHAR szKeyName[MAX_PATH];
HKEY hAppKey = NULL;
HKEY hSourceKey = NULL;
BOOL bReturn = FALSE;
StringCbCopyW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\");
StringCbCatW(szKeyName, sizeof(szKeyName), lpLogName);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
szKeyName,
0,
KEY_READ,
&hAppKey) == ERROR_SUCCESS)
{
if (RegOpenKeyExW(hAppKey,
SourceName,
0,
KEY_READ,
&hSourceKey) == ERROR_SUCCESS)
{
dwSize = MAX_PATH;
if (RegQueryValueExW(hSourceKey,
EntryName,
NULL,
NULL,
(LPBYTE)szModuleName,
&dwSize) == ERROR_SUCCESS)
{
/* Returns a string containing the requested substituted environment variable. */
ExpandEnvironmentStringsW((LPCWSTR)szModuleName, ExpandedName, MAX_PATH);
/* Successful */
bReturn = TRUE;
}
}
}
else
{
ShowLastWin32Error();
}
if (hSourceKey != NULL)
RegCloseKey(hSourceKey);
if (hAppKey != NULL)
RegCloseKey(hAppKey);
return bReturn;
}
static BOOL
ReadPageFileSettings(PVIRTMEM pVirtMem)
{
HKEY hkey = NULL;
DWORD dwType;
DWORD dwDataSize;
BOOL bRet = FALSE;
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
lpKey,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_QUERY_VALUE,
NULL,
&hkey,
NULL) == ERROR_SUCCESS)
{
if (RegQueryValueEx(hkey,
_T("PagingFiles"),
NULL,
&dwType,
NULL,
&dwDataSize) == ERROR_SUCCESS)
{
pVirtMem->szPagingFiles = (LPTSTR)HeapAlloc(GetProcessHeap(),
0,
dwDataSize);
if (pVirtMem->szPagingFiles != NULL)
{
ZeroMemory(pVirtMem->szPagingFiles,
dwDataSize);
if (RegQueryValueEx(hkey,
_T("PagingFiles"),
NULL,
&dwType,
(PBYTE)pVirtMem->szPagingFiles,
&dwDataSize) == ERROR_SUCCESS)
{
bRet = TRUE;
}
}
}
}
if (!bRet)
ShowLastWin32Error(pVirtMem->hSelf);
if (hkey != NULL)
RegCloseKey(hkey);
return bRet;
}
static VOID
WriteStartupRecoveryOptions(HWND hwndDlg, PSTARTINFO pStartInfo)
{
HKEY hKey;
DWORD lResult;
lResult = (DWORD)RegCreateKeyExW(HKEY_LOCAL_MACHINE,
L"System\\CurrentControlSet\\Control\\CrashControl",
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE,
NULL,
&hKey,
NULL);
if (lResult != ERROR_SUCCESS)
{
/* Failed to open key */
SetLastError(lResult);
ShowLastWin32Error(hwndDlg);
return;
}
lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECWRITEEVENT, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
RegSetValueExW(hKey, L"LogEvent", 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECSENDALERT, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
RegSetValueExW(hKey, L"SendAlert", 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECRESTART, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
RegSetValueExW(hKey, L"AutoReboot", 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECOVERWRITE, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
RegSetValueExW(hKey, L"Overwrite", 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
{
SendDlgItemMessage(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(WCHAR), (LPARAM)pStartInfo->szDumpFile);
RegSetValueExW(hKey, L"DumpFile", 0, REG_EXPAND_SZ, (LPBYTE)pStartInfo->szDumpFile, (wcslen(pStartInfo->szDumpFile) + 1) * sizeof(WCHAR));
}
else if (pStartInfo->dwCrashDumpEnabled == 3)
{
SendDlgItemMessage(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(WCHAR), (LPARAM)pStartInfo->szDumpFile);
RegSetValueExW(hKey, L"MinidumpDir", 0, REG_EXPAND_SZ, (LPBYTE)pStartInfo->szDumpFile, (wcslen(pStartInfo->szDumpFile) + 1) * sizeof(WCHAR));
}
RegSetValueExW(hKey, L"CrashDumpEnabled", 0, REG_DWORD, (LPBYTE)&pStartInfo->dwCrashDumpEnabled, sizeof(pStartInfo->dwCrashDumpEnabled));
RegCloseKey(hKey);
}
static BOOL
OnInitDialog(HWND hDlg, PLIC_CONTEXT pLicInfo)
{
HRSRC hResInfo;
HGLOBAL hResMem;
WCHAR *LicenseText;
pLicInfo->hIcon = LoadImage(hApplet,
MAKEINTRESOURCE(IDI_CPLSYSTEM),
IMAGE_ICON,
16,
16,
0);
SendMessage(hDlg,
WM_SETICON,
ICON_SMALL,
(LPARAM)pLicInfo->hIcon);
/* Load license from resource */
if (!(hResInfo = FindResource(hApplet,
MAKEINTRESOURCE(RC_LICENSE),
MAKEINTRESOURCE(RTDATA))) ||
!(hResMem = LoadResource(hApplet, hResInfo)) ||
!(LicenseText = LockResource(hResMem)))
{
ShowLastWin32Error(hDlg);
return FALSE;
}
/* Insert the license into the edit control (unicode!) */
SetDlgItemText(hDlg,
IDC_LICENCEEDIT,
LicenseText);
PostMessage(GetDlgItem(hDlg, IDC_LICENCEEDIT),
EM_SETSEL,
-1,
0);
PostMessage(GetDlgItem(hDlg, IDC_LICENCEEDIT), WM_VSCROLL, SB_TOP, 0);
return TRUE;
}
static void LoadClipboardDataFromFile(LPWSTR lpszFileName)
{
if (MessageBoxRes(Globals.hMainWnd, Globals.hInstance,
STRING_DELETE_MSG, STRING_DELETE_TITLE,
MB_ICONWARNING | MB_YESNO) != IDYES)
{
return;
}
if (!OpenClipboard(Globals.hMainWnd))
{
ShowLastWin32Error(Globals.hMainWnd);
return;
}
EmptyClipboard();
ReadClipboardFile(lpszFileName);
CloseClipboard();
}
void WriteClipboardFile(LPCWSTR lpFileName, WORD wFileIdentifier)
{
CLIPFILEHEADER ClipFileHeader;
CLIPFORMATHEADER ClipFormatArray;
NTCLIPFILEHEADER NtClipFileHeader;
NTCLIPFORMATHEADER NtClipFormatArray;
PVOID pClipFileHeader;
PVOID pClipFormatArray;
DWORD SizeOfFileHeader, SizeOfFormatHeader;
WORD wFormatCount;
DWORD dwFormatID;
DWORD dwLenData;
DWORD dwOffData;
// PVOID szName;
HANDLE hFile;
DWORD dwBytesWritten;
int i;
/* Create the file for write access */
hFile = CreateFileW(lpFileName, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
wFormatCount = CountClipboardFormats();
/* Select the file format and setup the header according to the clipboard file format ID */
switch (wFileIdentifier)
{
case CLIP_FMT_31:
SizeOfFileHeader = sizeof(CLIPFILEHEADER);
SizeOfFormatHeader = sizeof(CLIPFORMATHEADER);
pClipFileHeader = &ClipFileHeader;
pClipFormatArray = &ClipFormatArray;
ClipFileHeader.wFileIdentifier = CLIP_FMT_31; // wFileIdentifier
ClipFileHeader.wFormatCount = wFormatCount;
break;
case CLIP_FMT_NT:
case CLIP_FMT_BK:
SizeOfFileHeader = sizeof(NTCLIPFILEHEADER);
SizeOfFormatHeader = sizeof(NTCLIPFORMATHEADER);
pClipFileHeader = &NtClipFileHeader;
pClipFormatArray = &NtClipFormatArray;
NtClipFileHeader.wFileIdentifier = CLIP_FMT_NT; // wFileIdentifier
NtClipFileHeader.wFormatCount = wFormatCount;
break;
default:
MessageBoxRes(Globals.hMainWnd, Globals.hInstance, ERROR_INVALID_FILE_FORMAT, 0, MB_ICONSTOP | MB_OK);
goto done;
}
/* Write the header */
SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
if (!WriteFile(hFile, pClipFileHeader, SizeOfFileHeader, &dwBytesWritten, NULL) ||
dwBytesWritten != SizeOfFileHeader)
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
/* Compute where the data should start (after the file header and the format array) */
dwOffData = SizeOfFileHeader + wFormatCount * SizeOfFormatHeader;
/* Loop through each format and save the data */
i = 0;
dwFormatID = EnumClipboardFormats(0);
while (dwFormatID)
{
if (i >= wFormatCount)
{
/* Must never happen! */
assert(FALSE);
break;
}
/* Write the clipboard data at the specified offset, and retrieve its length */
if (!ClipboardWriteMemory(hFile, dwFormatID, dwOffData, &dwLenData))
goto Cont;
/* Write the format data header */
switch (wFileIdentifier)
{
case CLIP_FMT_31:
ZeroMemory(pClipFormatArray, sizeof(CLIPFORMATHEADER));
((CLIPFORMATHEADER*)pClipFormatArray)->dwFormatID = dwFormatID;
((CLIPFORMATHEADER*)pClipFormatArray)->dwLenData = dwLenData;
((CLIPFORMATHEADER*)pClipFormatArray)->dwOffData = dwOffData;
RetrieveClipboardFormatName(Globals.hInstance,
dwFormatID,
FALSE,
((CLIPFORMATHEADER*)pClipFormatArray)->szName,
ARRAYSIZE(((CLIPFORMATHEADER*)pClipFormatArray)->szName));
break;
case CLIP_FMT_NT:
case CLIP_FMT_BK:
ZeroMemory(pClipFormatArray, sizeof(NTCLIPFORMATHEADER));
((NTCLIPFORMATHEADER*)pClipFormatArray)->dwFormatID = dwFormatID;
((NTCLIPFORMATHEADER*)pClipFormatArray)->dwLenData = dwLenData;
((NTCLIPFORMATHEADER*)pClipFormatArray)->dwOffData = dwOffData;
RetrieveClipboardFormatName(Globals.hInstance,
dwFormatID,
TRUE,
((NTCLIPFORMATHEADER*)pClipFormatArray)->szName,
ARRAYSIZE(((NTCLIPFORMATHEADER*)pClipFormatArray)->szName));
break;
}
if (SetFilePointer(hFile, SizeOfFileHeader + i * SizeOfFormatHeader, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
if (!WriteFile(hFile, pClipFormatArray, SizeOfFormatHeader, &dwBytesWritten, NULL))
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
/* Adjust the offset for the next data stream */
dwOffData += dwLenData;
Cont:
i++;
dwFormatID = EnumClipboardFormats(dwFormatID);
}
done:
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
return;
}
void ReadClipboardFile(LPCWSTR lpFileName)
{
CLIPFILEHEADER ClipFileHeader;
CLIPFORMATHEADER ClipFormatArray;
NTCLIPFILEHEADER NtClipFileHeader;
NTCLIPFORMATHEADER NtClipFormatArray;
PVOID pClipFileHeader;
PVOID pClipFormatArray;
DWORD SizeOfFileHeader, SizeOfFormatHeader;
WORD wFileIdentifier;
WORD wFormatCount;
DWORD dwFormatID;
DWORD dwLenData;
DWORD dwOffData;
PVOID szName;
HANDLE hFile;
DWORD dwBytesRead;
BOOL bResult;
int i;
/* Open the file for read access */
hFile = CreateFileW(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
/* Just read enough bytes to get the clipboard file format ID */
if (!ReadFile(hFile, &wFileIdentifier, sizeof(wFileIdentifier), &dwBytesRead, NULL))
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
/* Set data according to the clipboard file format ID */
switch (wFileIdentifier)
{
case CLIP_FMT_31:
SizeOfFileHeader = sizeof(CLIPFILEHEADER);
SizeOfFormatHeader = sizeof(CLIPFORMATHEADER);
pClipFileHeader = &ClipFileHeader;
pClipFormatArray = &ClipFormatArray;
break;
case CLIP_FMT_NT:
case CLIP_FMT_BK:
SizeOfFileHeader = sizeof(NTCLIPFILEHEADER);
SizeOfFormatHeader = sizeof(NTCLIPFORMATHEADER);
pClipFileHeader = &NtClipFileHeader;
pClipFormatArray = &NtClipFormatArray;
break;
default:
MessageBoxRes(Globals.hMainWnd, Globals.hInstance, ERROR_INVALID_FILE_FORMAT, 0, MB_ICONSTOP | MB_OK);
goto done;
}
/* Completely read the header */
SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
if (!ReadFile(hFile, pClipFileHeader, SizeOfFileHeader, &dwBytesRead, NULL) ||
dwBytesRead != SizeOfFileHeader)
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
/* Get header data */
switch (wFileIdentifier)
{
case CLIP_FMT_31:
assert(wFileIdentifier == ((CLIPFILEHEADER*)pClipFileHeader)->wFileIdentifier);
wFormatCount = ((CLIPFILEHEADER*)pClipFileHeader)->wFormatCount;
break;
case CLIP_FMT_NT:
case CLIP_FMT_BK:
assert(wFileIdentifier == ((NTCLIPFILEHEADER*)pClipFileHeader)->wFileIdentifier);
wFormatCount = ((NTCLIPFILEHEADER*)pClipFileHeader)->wFormatCount;
break;
}
/* Loop through the format data array */
for (i = 0; i < wFormatCount; i++)
{
if (SetFilePointer(hFile, SizeOfFileHeader + i * SizeOfFormatHeader, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
if (!ReadFile(hFile, pClipFormatArray, SizeOfFormatHeader, &dwBytesRead, NULL))
{
ShowLastWin32Error(Globals.hMainWnd);
goto done;
}
/* Get format data */
switch (wFileIdentifier)
{
case CLIP_FMT_31:
dwFormatID = ((CLIPFORMATHEADER*)pClipFormatArray)->dwFormatID;
dwLenData = ((CLIPFORMATHEADER*)pClipFormatArray)->dwLenData;
dwOffData = ((CLIPFORMATHEADER*)pClipFormatArray)->dwOffData;
szName = ((CLIPFORMATHEADER*)pClipFormatArray)->szName;
break;
case CLIP_FMT_NT:
case CLIP_FMT_BK:
dwFormatID = ((NTCLIPFORMATHEADER*)pClipFormatArray)->dwFormatID;
dwLenData = ((NTCLIPFORMATHEADER*)pClipFormatArray)->dwLenData;
dwOffData = ((NTCLIPFORMATHEADER*)pClipFormatArray)->dwOffData;
szName = ((NTCLIPFORMATHEADER*)pClipFormatArray)->szName;
break;
}
switch (dwFormatID)
{
case CF_OWNERDISPLAY:
{
break;
}
case CF_DSPBITMAP:
case CF_BITMAP:
{
bResult = ClipboardReadBitmap(hFile, dwOffData, dwLenData);
break;
}
case CF_DSPMETAFILEPICT:
case CF_METAFILEPICT:
{
bResult = ClipboardReadMetafile(hFile, dwOffData, dwLenData);
break;
}
case CF_DSPENHMETAFILE:
case CF_ENHMETAFILE:
{
bResult = ClipboardReadEnhMetafile(hFile, dwOffData, dwLenData);
break;
}
case CF_PALETTE:
{
bResult = ClipboardReadPalette(hFile, dwOffData, dwLenData);
break;
}
default:
{
if ((dwFormatID < CF_PRIVATEFIRST) || (dwFormatID > CF_PRIVATELAST))
{
bResult = ClipboardReadMemory(hFile, dwFormatID, dwOffData, dwLenData, wFileIdentifier, szName);
}
break;
}
}
if (!bResult)
ShowLastWin32Error(Globals.hMainWnd);
}
done:
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
return;
}
static VOID
WritePageFileSettings(PVIRTMEM pVirtMem)
{
HKEY hk = NULL;
TCHAR szPagingFiles[2048];
TCHAR szText[256];
INT i, nPos = 0;
BOOL bErr = TRUE;
for (i = 0; i < pVirtMem->Count; ++i)
{
if (pVirtMem->Pagefile[i].bUsed &&
pVirtMem->Pagefile[i].NewMinSize != -1 &&
pVirtMem->Pagefile[i].NewMaxSize != -1)
{
_stprintf(szText,
_T("%s\\pagefile.sys %i %i"),
pVirtMem->Pagefile[i].szDrive,
pVirtMem->Pagefile[i].NewMinSize,
pVirtMem->Pagefile[i].NewMaxSize);
/* Add it to our overall registry string */
lstrcpy(szPagingFiles + nPos, szText);
/* Record the position where the next string will start */
nPos += (INT)lstrlen(szText) + 1;
/* Add another NULL for REG_MULTI_SZ */
szPagingFiles[nPos] = _T('\0');
nPos++;
}
}
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
lpKey,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE,
NULL,
&hk,
NULL) == ERROR_SUCCESS)
{
if (RegSetValueEx(hk,
_T("PagingFiles"),
0,
REG_MULTI_SZ,
(LPBYTE) szPagingFiles,
(DWORD) nPos * sizeof(TCHAR)) == ERROR_SUCCESS)
{
bErr = FALSE;
}
RegCloseKey(hk);
}
if (bErr == FALSE)
{
/* Delete obsolete paging files on the next boot */
for (i = 0; i < 26; i++)
{
if (pVirtMem->Pagefile[i].OldMinSize != -1 &&
pVirtMem->Pagefile[i].NewMinSize == -1)
{
_stprintf(szText,
_T("%s\\pagefile.sys"),
pVirtMem->Pagefile[i].szDrive);
MoveFileEx(szText, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
}
}
}
if (bErr)
ShowLastWin32Error(pVirtMem->hSelf);
}
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
{
MSG msg;
HACCEL hAccel;
HWND hPrevWindow;
WNDCLASSEXW wndclass;
WCHAR szBuffer[MAX_STRING_LEN];
hPrevWindow = FindWindowW(szClassName, NULL);
if (hPrevWindow)
{
BringWindowToFront(hPrevWindow);
return 0;
}
switch (GetUserDefaultUILanguage())
{
case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
SetProcessDefaultLayout(LAYOUT_RTL);
break;
default:
break;
}
ZeroMemory(&Globals, sizeof(Globals));
Globals.hInstance = hInstance;
ZeroMemory(&wndclass, sizeof(wndclass));
wndclass.cbSize = sizeof(wndclass);
wndclass.lpfnWndProc = MainWndProc;
wndclass.hInstance = hInstance;
wndclass.hIcon = LoadIconW(hInstance, MAKEINTRESOURCEW(CLIPBRD_ICON));
wndclass.hCursor = LoadCursorW(0, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wndclass.lpszMenuName = MAKEINTRESOURCEW(MAIN_MENU);
wndclass.lpszClassName = szClassName;
if (!RegisterClassExW(&wndclass))
{
ShowLastWin32Error(NULL);
return 0;
}
ZeroMemory(&Scrollstate, sizeof(Scrollstate));
LoadStringW(hInstance, STRING_CLIPBOARD, szBuffer, ARRAYSIZE(szBuffer));
Globals.hMainWnd = CreateWindowExW(WS_EX_CLIENTEDGE | WS_EX_ACCEPTFILES,
szClassName,
szBuffer,
WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL,
NULL,
Globals.hInstance,
NULL);
if (!Globals.hMainWnd)
{
ShowLastWin32Error(NULL);
return 0;
}
ShowWindow(Globals.hMainWnd, nCmdShow);
UpdateWindow(Globals.hMainWnd);
hAccel = LoadAcceleratorsW(Globals.hInstance, MAKEINTRESOURCEW(ID_ACCEL));
if (!hAccel)
{
ShowLastWin32Error(Globals.hMainWnd);
}
/* If the user provided a path to a clipboard data file, try to open it */
if (__argc >= 2)
LoadClipboardDataFromFile(__wargv[1]);
while (GetMessageW(&msg, 0, 0, 0))
{
if (!TranslateAcceleratorW(Globals.hMainWnd, hAccel, &msg))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return (int)msg.wParam;
}
BOOL
QueryEventMessages(LPWSTR lpMachineName,
LPWSTR lpLogName)
{
HWND hwndDlg = NULL;
HANDLE hEventLog;
EVENTLOGRECORD *pevlr;
DWORD dwRead, dwNeeded, dwThisRecord, dwTotalRecords = 0, dwCurrentRecord = 0, dwRecordsToRead = 0, dwFlags, dwMaxLength;
size_t cchRemaining;
LPWSTR lpSourceName;
LPWSTR lpComputerName;
LPSTR lpData;
BOOL bResult = TRUE; /* Read succeeded. */
WCHAR szWindowTitle[MAX_PATH];
WCHAR szStatusText[MAX_PATH];
WCHAR szLocalDate[MAX_PATH];
WCHAR szLocalTime[MAX_PATH];
WCHAR szEventID[MAX_PATH];
WCHAR szEventTypeText[MAX_LOADSTRING];
WCHAR szCategoryID[MAX_PATH];
WCHAR szUsername[MAX_PATH];
WCHAR szEventText[EVENT_MESSAGE_FILE_BUFFER];
WCHAR szCategory[MAX_PATH];
WCHAR szData[MAX_PATH];
PWCHAR lpTitleTemplateEnd;
SYSTEMTIME time;
LVITEMW lviEventItem;
dwFlags = EVENTLOG_FORWARDS_READ | EVENTLOG_SEQUENTIAL_READ;
/* Open the event log. */
hEventLog = OpenEventLogW(lpMachineName,
lpLogName);
if (hEventLog == NULL)
{
ShowLastWin32Error();
return FALSE;
}
lpSourceLogName = lpLogName;
lpComputerName = lpMachineName;
/* Disable listview redraw */
SendMessage(hwndListView, WM_SETREDRAW, FALSE, 0);
/* Clear the list view */
(void)ListView_DeleteAllItems (hwndListView);
FreeRecords();
GetOldestEventLogRecord(hEventLog, &dwThisRecord);
/* Get the total number of event log records. */
GetNumberOfEventLogRecords (hEventLog , &dwTotalRecords);
g_TotalRecords = dwTotalRecords;
if (dwTotalRecords > 0)
{
EnableMenuItem(hMainMenu, IDM_CLEAR_EVENTS, MF_BYCOMMAND | MF_ENABLED);
EnableMenuItem(hMainMenu, IDM_SAVE_PROTOCOL, MF_BYCOMMAND | MF_ENABLED);
}
else
{
EnableMenuItem(hMainMenu, IDM_CLEAR_EVENTS, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(hMainMenu, IDM_SAVE_PROTOCOL, MF_BYCOMMAND | MF_GRAYED);
}
g_RecordPtrs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwTotalRecords * sizeof(PVOID));
/* If we have at least 1000 records show the waiting dialog */
if (dwTotalRecords > 1000)
{
CloseHandle(CreateThread(NULL,
0,
ShowStatusMessageThread,
(LPVOID)&hwndDlg,
0,
NULL));
}
while (dwCurrentRecord < dwTotalRecords)
{
pevlr = HeapAlloc(GetProcessHeap(), 0, sizeof(EVENTLOGRECORD));
g_RecordPtrs[dwCurrentRecord] = pevlr;
bResult = ReadEventLog(hEventLog, // Event log handle
dwFlags, // Sequential read
0, // Ignored for sequential read
pevlr, // Pointer to buffer
sizeof(EVENTLOGRECORD), // Size of buffer
&dwRead, // Number of bytes read
&dwNeeded); // Bytes in the next record
if((!bResult) && (GetLastError () == ERROR_INSUFFICIENT_BUFFER))
{
HeapFree(GetProcessHeap(), 0, pevlr);
pevlr = HeapAlloc(GetProcessHeap(), 0, dwNeeded);
g_RecordPtrs[dwCurrentRecord] = pevlr;
ReadEventLogW(hEventLog, // event log handle
dwFlags, // read flags
0, // offset; default is 0
pevlr, // pointer to buffer
dwNeeded, // size of buffer
&dwRead, // number of bytes read
&dwNeeded); // bytes in next record
}
while (dwRead > 0)
{
LoadStringW(hInst, IDS_NOT_AVAILABLE, szUsername, MAX_PATH);
LoadStringW(hInst, IDS_NOT_AVAILABLE, szEventText, MAX_PATH);
LoadStringW(hInst, IDS_NONE, szCategory, MAX_PATH);
// Get the event source name.
lpSourceName = (LPWSTR)((LPBYTE)pevlr + sizeof(EVENTLOGRECORD));
// Get the computer name
lpComputerName = (LPWSTR)((LPBYTE)pevlr + sizeof(EVENTLOGRECORD) + (wcslen(lpSourceName) + 1) * sizeof(WCHAR));
// This ist the data section of the current event
lpData = (LPSTR)((LPBYTE)pevlr + pevlr->DataOffset);
// Compute the event type
EventTimeToSystemTime(pevlr->TimeWritten, &time);
// Get the username that generated the event
GetEventUserName(pevlr, szUsername);
GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &time, NULL, szLocalDate, MAX_PATH);
GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &time, NULL, szLocalTime, MAX_PATH);
GetEventType(pevlr->EventType, szEventTypeText);
GetEventCategory(lpLogName, lpSourceName, pevlr, szCategory);
StringCbPrintfW(szEventID, sizeof(szEventID), L"%u", (pevlr->EventID & 0xFFFF));
StringCbPrintfW(szCategoryID, sizeof(szCategoryID), L"%u", pevlr->EventCategory);
lviEventItem.mask = LVIF_IMAGE | LVIF_TEXT | LVIF_PARAM;
lviEventItem.iItem = 0;
lviEventItem.iSubItem = 0;
lviEventItem.lParam = (LPARAM)pevlr;
lviEventItem.pszText = szEventTypeText;
switch (pevlr->EventType)
{
case EVENTLOG_ERROR_TYPE:
lviEventItem.iImage = 2;
break;
case EVENTLOG_AUDIT_FAILURE:
lviEventItem.iImage = 2;
break;
case EVENTLOG_WARNING_TYPE:
lviEventItem.iImage = 1;
break;
case EVENTLOG_INFORMATION_TYPE:
lviEventItem.iImage = 0;
break;
case EVENTLOG_AUDIT_SUCCESS:
lviEventItem.iImage = 0;
break;
case EVENTLOG_SUCCESS:
lviEventItem.iImage = 0;
break;
}
lviEventItem.iItem = ListView_InsertItem(hwndListView, &lviEventItem);
ListView_SetItemText(hwndListView, lviEventItem.iItem, 1, szLocalDate);
ListView_SetItemText(hwndListView, lviEventItem.iItem, 2, szLocalTime);
ListView_SetItemText(hwndListView, lviEventItem.iItem, 3, lpSourceName);
ListView_SetItemText(hwndListView, lviEventItem.iItem, 4, szCategory);
ListView_SetItemText(hwndListView, lviEventItem.iItem, 5, szEventID);
ListView_SetItemText(hwndListView, lviEventItem.iItem, 6, szUsername); //User
ListView_SetItemText(hwndListView, lviEventItem.iItem, 7, lpComputerName); //Computer
MultiByteToWideChar(CP_ACP,
0,
lpData,
pevlr->DataLength,
szData,
MAX_PATH);
ListView_SetItemText(hwndListView, lviEventItem.iItem, 8, szData); //Event Text
dwRead -= pevlr->Length;
pevlr = (EVENTLOGRECORD *)((LPBYTE) pevlr + pevlr->Length);
}
dwRecordsToRead--;
dwCurrentRecord++;
}
// All events loaded
if(hwndDlg)
EndDialog(hwndDlg, 0);
StringCchPrintfExW(szWindowTitle,
sizeof(szWindowTitle) / sizeof(WCHAR),
&lpTitleTemplateEnd,
&cchRemaining,
0,
szTitleTemplate, szTitle, lpLogName); /* i = number of characters written */
/* lpComputerName can be NULL here if no records was read */
dwMaxLength = (DWORD)cchRemaining;
if (!lpComputerName)
GetComputerNameW(lpTitleTemplateEnd, &dwMaxLength);
else
StringCchCopyW(lpTitleTemplateEnd, dwMaxLength, lpComputerName);
StringCbPrintfW(szStatusText, sizeof(szStatusText), szStatusBarTemplate, lpLogName, dwTotalRecords);
// Update the status bar
SendMessageW(hwndStatus, SB_SETTEXT, (WPARAM)0, (LPARAM)szStatusText);
// Set the window title
SetWindowTextW(hwndMainWindow, szWindowTitle);
// Resume list view redraw
SendMessageW(hwndListView, WM_SETREDRAW, TRUE, 0);
// Close the event log.
CloseEventLog(hEventLog);
return TRUE;
}
static VOID
LoadRecoveryOptions(HWND hwndDlg, PSTARTINFO pStartInfo)
{
HKEY hKey;
WCHAR szName[MAX_PATH];
DWORD dwValue, dwValueLength, dwType, dwResult;
dwResult = (DWORD)RegCreateKeyExW(HKEY_LOCAL_MACHINE,
L"System\\CurrentControlSet\\Control\\CrashControl",
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_READ,
NULL,
&hKey,
NULL);
if (dwResult != ERROR_SUCCESS)
{
/* Failed to open key */
SetLastError(dwResult);
ShowLastWin32Error(hwndDlg);
EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECWRITEEVENT), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECSENDALERT), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECRESTART), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECDEBUGCOMBO), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECDUMPFILE), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECOVERWRITE), FALSE);
SaveRecoveryOptions = FALSE;
return;
}
dwValueLength = sizeof(DWORD);
if (RegQueryValueExW(hKey, L"LogEvent", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
SendDlgItemMessageW(hwndDlg, IDC_STRRECWRITEEVENT, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
dwValueLength = sizeof(DWORD);
if (RegQueryValueExW(hKey, L"SendAlert", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
SendDlgItemMessageW(hwndDlg, IDC_STRRECSENDALERT, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
dwValueLength = sizeof(DWORD);
if (RegQueryValueExW(hKey, L"AutoReboot", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
SendDlgItemMessageW(hwndDlg, IDC_STRRECRESTART, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
dwValueLength = sizeof(DWORD);
if (RegQueryValueExW(hKey, L"Overwrite", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
SendDlgItemMessageW(hwndDlg, IDC_STRRECOVERWRITE, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
dwValueLength = sizeof(DWORD);
if (RegQueryValueExW(hKey, L"CrashDumpEnabled", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
pStartInfo->dwCrashDumpEnabled = dwValue;
dwValueLength = sizeof(pStartInfo->szDumpFile);
if (RegQueryValueExW(hKey, L"DumpFile", NULL, &dwType, (LPBYTE)pStartInfo->szDumpFile, &dwValueLength) != ERROR_SUCCESS)
pStartInfo->szDumpFile[0] = L'\0';
dwValueLength = sizeof(pStartInfo->szMinidumpDir);
if (RegQueryValueExW(hKey, L"MinidumpDir", NULL, &dwType, (LPBYTE)pStartInfo->szMinidumpDir, &dwValueLength) != ERROR_SUCCESS)
pStartInfo->szMinidumpDir[0] = L'\0';
if (LoadStringW(hApplet, IDS_NO_DUMP, szName, sizeof(szName) / sizeof(WCHAR)))
{
szName[(sizeof(szName)/sizeof(WCHAR))-1] = L'\0';
SendDlgItemMessageW(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szName);
}
if (LoadStringW(hApplet, IDS_FULL_DUMP, szName, sizeof(szName) / sizeof(WCHAR)))
{
szName[(sizeof(szName)/sizeof(WCHAR))-1] = L'\0';
SendDlgItemMessageW(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szName);
}
if (LoadStringW(hApplet, IDS_KERNEL_DUMP, szName, sizeof(szName) / sizeof(WCHAR)))
{
szName[(sizeof(szName)/sizeof(WCHAR))-1] = L'\0';
SendDlgItemMessageW(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szName);
}
if (LoadStringW(hApplet, IDS_MINI_DUMP, szName, sizeof(szName) / sizeof(WCHAR)))
{
szName[(sizeof(szName)/sizeof(WCHAR))-1] = L'\0';
SendDlgItemMessageW(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szName);
}
SetCrashDlgItems(hwndDlg, pStartInfo);
RegCloseKey(hKey);
SaveRecoveryOptions = TRUE;
}
