511 lines
11 KiB
C++
511 lines
11 KiB
C++
|
|
#include "precomp.h"
|
|
|
|
typedef struct _VLOG_GLOBAL_DATA {
|
|
BOOL bLoggingDisabled;
|
|
WCHAR szSessionLog[MAX_PATH];
|
|
WCHAR szProcessLog[MAX_PATH];
|
|
} VLOG_GLOBAL_DATA, *PVLOG_GLOBAL_DATA;
|
|
|
|
|
|
PVLOG_GLOBAL_DATA g_pData = NULL;
|
|
|
|
HANDLE g_hMap = NULL; // mapping handle for global data
|
|
BOOL g_bVerifierLogInited = FALSE; // have we been through the init sequence?
|
|
BOOL g_bLoggingDisabled = TRUE; // have we been through the init sequence?
|
|
|
|
|
|
WCHAR g_szSessionLog[MAX_PATH];
|
|
WCHAR g_szProcessLog[MAX_PATH];
|
|
|
|
#define DEBUGGER_LOG L"DEBUGGER"
|
|
#define DEBUGGER_ENTRY_CRASH L"Crash"
|
|
#define DEBUGGER_ENTRY_CRASH_DESCRIPTION L"An AV occured. The application exited."
|
|
|
|
void
|
|
WriteToProcessLog(
|
|
LPCSTR szLine
|
|
);
|
|
|
|
void
|
|
WriteToSessionLog(
|
|
LPCSTR szLine
|
|
);
|
|
|
|
void
|
|
GetExeName(
|
|
LPWSTR szProcessPath,
|
|
LPWSTR szProcessName
|
|
)
|
|
{
|
|
LPWSTR pszLast = NULL;
|
|
LPWSTR psz;
|
|
LPWSTR pszFound = NULL;
|
|
|
|
psz = szProcessPath;
|
|
|
|
while (psz) {
|
|
pszFound = wcschr(psz, L'\\');
|
|
|
|
if (pszFound != NULL) {
|
|
pszLast = pszFound;
|
|
psz = pszFound + 1;
|
|
} else {
|
|
psz = pszFound;
|
|
}
|
|
}
|
|
|
|
if (pszLast != NULL) {
|
|
psz = pszLast + 1;
|
|
} else {
|
|
psz = szProcessPath;
|
|
}
|
|
|
|
pszFound = wcschr(psz, L'.');
|
|
|
|
if (pszFound != NULL) {
|
|
wcsncpy(szProcessName, psz, pszFound - psz);
|
|
} else {
|
|
wcscpy(szProcessName, psz);
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Initializes the support for file logging.
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful, FALSE if failed
|
|
|
|
History:
|
|
|
|
04/26/2001 dmunsil Created
|
|
|
|
--*/
|
|
BOOL
|
|
InitVerifierLogSupport(
|
|
LPWSTR szProcessPath,
|
|
DWORD dwID
|
|
)
|
|
{
|
|
WCHAR szShared[128];
|
|
WCHAR szVLogPath[MAX_PATH];
|
|
WCHAR szProcessName[MAX_PATH];
|
|
WCHAR szTime[128];
|
|
char szTemp[400];
|
|
HANDLE hFile;
|
|
SYSTEMTIME LocalTime;
|
|
int nTemp;
|
|
BOOL bAlreadyInited;
|
|
DWORD dwErr;
|
|
|
|
//
|
|
// if we've already been inited, get out
|
|
//
|
|
if (g_bVerifierLogInited) {
|
|
return FALSE;
|
|
}
|
|
g_bVerifierLogInited = TRUE;
|
|
|
|
swprintf(szShared, L"VeriferLog_%08X", dwID);
|
|
|
|
g_hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, szShared);
|
|
if (g_hMap) {
|
|
bAlreadyInited = TRUE;
|
|
} else {
|
|
bAlreadyInited = FALSE;
|
|
g_hMap = CreateFileMapping(INVALID_HANDLE_VALUE,
|
|
NULL,
|
|
PAGE_READWRITE,
|
|
0,
|
|
sizeof(VLOG_GLOBAL_DATA),
|
|
szShared);
|
|
}
|
|
|
|
if (!g_hMap) {
|
|
DPF("Cannot get shared global data.");
|
|
g_bLoggingDisabled = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
g_pData = (PVLOG_GLOBAL_DATA)MapViewOfFile(g_hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
|
|
if (!g_pData) {
|
|
DPF("Cannot map shared global data.");
|
|
g_bLoggingDisabled = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
if (bAlreadyInited) {
|
|
if (g_pData->szProcessLog[0] == 0 || g_pData->szSessionLog[0] == 0) {
|
|
g_bLoggingDisabled = TRUE;
|
|
g_pData->bLoggingDisabled = TRUE;
|
|
return FALSE;
|
|
}
|
|
g_bLoggingDisabled = g_pData->bLoggingDisabled;
|
|
|
|
wcscpy(g_szSessionLog, g_pData->szSessionLog);
|
|
wcscpy(g_szProcessLog, g_pData->szProcessLog);
|
|
return TRUE;
|
|
} else {
|
|
//
|
|
// just in case -- make sure these are NULL
|
|
//
|
|
ZeroMemory(g_pData, sizeof(VLOG_GLOBAL_DATA));
|
|
}
|
|
|
|
//
|
|
// we need to init the file mapping, so temporarily disable logging, just in case.
|
|
//
|
|
g_pData->bLoggingDisabled = TRUE;
|
|
|
|
//
|
|
// init the CString objects
|
|
//
|
|
|
|
//
|
|
// the verifier log will be located in %windir%\AppPatch\VLog
|
|
//
|
|
|
|
//
|
|
// First, check that VLog exists; if not, we're not logging
|
|
//
|
|
GetSystemWindowsDirectoryW(szVLogPath, MAX_PATH);
|
|
|
|
wcscat(szVLogPath, L"\\AppPatch\\VLog");
|
|
|
|
if (GetFileAttributesW(szVLogPath) == -1) {
|
|
|
|
if (!CreateDirectory(szVLogPath, NULL)) {
|
|
DPF("No log directory %ls. Logging disabled.", szVLogPath);
|
|
g_bLoggingDisabled = TRUE;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Next, check for the existence of session.log. If it's not there,
|
|
// we're not logging
|
|
//
|
|
wcscpy(g_szSessionLog, szVLogPath);
|
|
wcscat(g_szSessionLog, L"\\session.log");
|
|
|
|
if (GetFileAttributesW(g_szSessionLog) == -1) {
|
|
|
|
hFile = CreateFile(g_szSessionLog,
|
|
GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
if (hFile != INVALID_HANDLE_VALUE) {
|
|
CloseHandle(hFile);
|
|
} else {
|
|
DPF("No session log file '%ls'. Logging disabled.", g_szSessionLog);
|
|
g_bLoggingDisabled = TRUE;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// get the process log file name
|
|
//
|
|
GetExeName(szProcessPath, szProcessName);
|
|
|
|
//
|
|
// combine into log name, find first available
|
|
//
|
|
nTemp = 0;
|
|
do {
|
|
swprintf(g_szProcessLog, L"%ls\\%ls%d.%ls", szVLogPath, szProcessName, nTemp, L"log");
|
|
|
|
nTemp++;
|
|
} while (GetFileAttributesW(g_szProcessLog) != -1);
|
|
|
|
//
|
|
// open the file. create it if it doesn't exist, and truncate
|
|
//
|
|
hFile = CreateFileW(g_szProcessLog,
|
|
GENERIC_ALL,
|
|
0,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE) {
|
|
dwErr = GetLastError();
|
|
|
|
DPF("Cannot create verifier process log file '%ls'. Error 0x%08X.",
|
|
g_szProcessLog, dwErr);
|
|
|
|
g_bLoggingDisabled = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
CloseHandle(hFile);
|
|
|
|
//
|
|
// put the info in the session log and the process log
|
|
//
|
|
g_pData->bLoggingDisabled = FALSE;
|
|
g_bLoggingDisabled = FALSE;
|
|
|
|
|
|
//
|
|
// I realize these pointers point to process-specific memory, but since
|
|
// this mapping is only shared by this process, it seems safe.
|
|
//
|
|
wcscpy(g_pData->szProcessLog, g_szProcessLog);
|
|
wcscpy(g_pData->szSessionLog, g_szSessionLog);
|
|
|
|
GetLocalTime(&LocalTime);
|
|
|
|
swprintf(szTime,
|
|
L"%d/%d/%d %d:%02d:%02d",
|
|
LocalTime.wMonth,
|
|
LocalTime.wDay,
|
|
LocalTime.wYear,
|
|
LocalTime.wHour,
|
|
LocalTime.wMinute,
|
|
LocalTime.wSecond);
|
|
|
|
sprintf(szTemp,
|
|
"# LOG_BEGIN %ls '%ls' '%ls'",
|
|
szTime,
|
|
szProcessPath,
|
|
g_szProcessLog);
|
|
|
|
WriteToProcessLog(szTemp);
|
|
WriteToSessionLog(szTemp);
|
|
|
|
//
|
|
// Dump the log provider info
|
|
//
|
|
sprintf(szTemp, "# SHIM_BEGIN %ls 1", DEBUGGER_LOG);
|
|
WriteToProcessLog(szTemp);
|
|
|
|
sprintf(szTemp, "# LOGENTRY %ls 0 '%ls", DEBUGGER_LOG, DEBUGGER_ENTRY_CRASH);
|
|
WriteToProcessLog(szTemp);
|
|
|
|
WriteToProcessLog("# DESCRIPTION BEGIN");
|
|
sprintf(szTemp, "%ls", DEBUGGER_ENTRY_CRASH_DESCRIPTION);
|
|
WriteToProcessLog(szTemp);
|
|
WriteToProcessLog("# DESCRIPTION END");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
clean up all our shared file resources
|
|
|
|
History:
|
|
|
|
04/26/2001 dmunsil Created
|
|
|
|
--*/
|
|
void
|
|
ReleaseLogSupport(
|
|
void
|
|
)
|
|
{
|
|
g_bLoggingDisabled = TRUE;
|
|
if (g_pData) {
|
|
UnmapViewOfFile(g_pData);
|
|
g_pData = NULL;
|
|
if (g_hMap) {
|
|
CloseHandle(g_hMap);
|
|
g_hMap = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Logs a problem that the verifier has found
|
|
|
|
History:
|
|
|
|
04/26/2001 dmunsil Created
|
|
|
|
--*/
|
|
void
|
|
VLog(
|
|
LPCSTR pszFmt,
|
|
...
|
|
)
|
|
{
|
|
char szT[1024];
|
|
char* szTemp;
|
|
int nLen;
|
|
int nRemain;
|
|
va_list arglist;
|
|
|
|
if (g_bLoggingDisabled) {
|
|
return;
|
|
}
|
|
|
|
_snprintf(szT, 1023, "| %ls 0 '", DEBUGGER_LOG);
|
|
|
|
nLen = lstrlenA(szT);
|
|
szTemp = szT + nLen;
|
|
nRemain = 1023 - nLen;
|
|
|
|
if (nRemain > 0) {
|
|
va_start(arglist, pszFmt);
|
|
_vsnprintf(szTemp, nRemain, pszFmt, arglist);
|
|
va_end(arglist);
|
|
}
|
|
|
|
szT[1023] = 0;
|
|
WriteToProcessLog(szT);
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Writes a line of text to the process log file
|
|
|
|
Return Value:
|
|
|
|
History:
|
|
|
|
04/26/2001 dmunsil Created
|
|
|
|
--*/
|
|
void
|
|
WriteToProcessLog(
|
|
LPCSTR szLine
|
|
)
|
|
{
|
|
HANDLE hFile;
|
|
DWORD bytesWritten;
|
|
|
|
if (g_bLoggingDisabled) {
|
|
return;
|
|
}
|
|
|
|
// open the log file
|
|
|
|
hFile = CreateFileW(g_szProcessLog,
|
|
GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE) {
|
|
DPF("Cannot open verifier log file '%s'", g_szProcessLog);
|
|
return;
|
|
}
|
|
|
|
// go to the end of the file
|
|
|
|
SetFilePointer(hFile, 0, NULL, FILE_END);
|
|
|
|
// make sure we have no '\n' or '\r' at the end of the string.
|
|
|
|
int len = lstrlenA(szLine);
|
|
|
|
while (len && (szLine[len - 1] == '\n' || szLine[len - 1] == '\r')) {
|
|
len--;
|
|
}
|
|
|
|
// write the actual log
|
|
|
|
WriteFile(hFile, szLine, len, &bytesWritten, NULL);
|
|
|
|
// new line
|
|
|
|
WriteFile(hFile, "\r\n", 2, &bytesWritten, NULL);
|
|
|
|
CloseHandle(hFile);
|
|
|
|
// dump it in the debugger as well on checked builds
|
|
#if DBG
|
|
DPF((LPSTR)szLine);
|
|
#endif // DBG
|
|
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Writes a line of text to the session log file
|
|
|
|
Return Value:
|
|
|
|
History:
|
|
|
|
04/26/2001 dmunsil Created
|
|
|
|
--*/
|
|
void
|
|
WriteToSessionLog(
|
|
LPCSTR szLine
|
|
)
|
|
{
|
|
HANDLE hFile;
|
|
DWORD bytesWritten;
|
|
|
|
if (g_bLoggingDisabled) {
|
|
return;
|
|
}
|
|
|
|
// open the log file
|
|
|
|
hFile = CreateFileW(g_szSessionLog,
|
|
GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE) {
|
|
DPF("Cannot open verifier log file '%s'", g_szSessionLog);
|
|
return;
|
|
}
|
|
|
|
// go to the end of the file
|
|
|
|
SetFilePointer(hFile, 0, NULL, FILE_END);
|
|
|
|
// make sure we have no '\n' or '\r' at the end of the string.
|
|
|
|
int len = lstrlenA(szLine);
|
|
|
|
while (len && (szLine[len - 1] == '\n' || szLine[len - 1] == '\r')) {
|
|
len--;
|
|
}
|
|
|
|
// write the actual log
|
|
|
|
WriteFile(hFile, szLine, len, &bytesWritten, NULL);
|
|
|
|
// new line
|
|
|
|
WriteFile(hFile, "\r\n", 2, &bytesWritten, NULL);
|
|
|
|
CloseHandle(hFile);
|
|
|
|
// dump it in the debugger as well on checked builds
|
|
#if DBG
|
|
DPF((LPSTR)szLine);
|
|
#endif // DBG
|
|
}
|
|
|