747 lines
22 KiB
C
747 lines
22 KiB
C
/*
|
|
+-------------------------------------------------------------------------+
|
|
| Logging Routines |
|
|
+-------------------------------------------------------------------------+
|
|
| (c) Copyright 1994 |
|
|
| Microsoft Corp. |
|
|
| All rights reserved |
|
|
| |
|
|
| Program : [NWLog.c] |
|
|
| Programmer : Arthur Hanson |
|
|
| Original Program Date : [Dec 01, 1993] |
|
|
| Last Update : [Jun 16, 1994] |
|
|
| |
|
|
| Version: 1.00 |
|
|
| |
|
|
| Description: |
|
|
| |
|
|
| History: |
|
|
| arth Jun 16, 1994 1.00 Original Version. |
|
|
| |
|
|
+-------------------------------------------------------------------------+
|
|
*/
|
|
|
|
|
|
#include "globals.h"
|
|
|
|
#include <io.h>
|
|
#include <malloc.h>
|
|
#include <string.h>
|
|
|
|
#define VER_HI 1
|
|
#define VER_LOW 1
|
|
|
|
HANDLE hErr = NULL;
|
|
HANDLE hLog = NULL;
|
|
HANDLE hSummary = NULL;
|
|
|
|
#define STD_EXT "LOG"
|
|
#define ERR_FILENAME "Error."
|
|
#define LOG_FILENAME "LogFile."
|
|
#define SUMMARY_FILENAME "Summary."
|
|
|
|
#define MAX_LOG_STR 1024
|
|
#define FILENAME_LOG "LogFile.LOG"
|
|
#define FILENAME_ERROR "Error.LOG"
|
|
#define FILENAME_SUMMARY "Summary.LOG"
|
|
|
|
static char LogFileName[MAX_PATH + 1];
|
|
static char ErrorLogFileName[MAX_PATH + 1];
|
|
static char SummaryLogFileName[MAX_PATH + 1];
|
|
static char Spaces[] = " ";
|
|
|
|
static BOOL ErrorFlag;
|
|
static TCHAR ErrorContext[MAX_LOG_STR];
|
|
static TCHAR ErrorCategory[MAX_LOG_STR];
|
|
static TCHAR ErrorItem[MAX_LOG_STR];
|
|
static TCHAR ErrorText[MAX_LOG_STR];
|
|
static TCHAR tmpStr[MAX_LOG_STR];
|
|
static BOOL CategoryWritten;
|
|
static BOOL ContextWritten;
|
|
static BOOL CategorySet;
|
|
static BOOL ItemSet;
|
|
|
|
static BOOL VerboseULogging = TRUE;
|
|
static BOOL VerboseFLogging = TRUE;
|
|
static BOOL ErrorBreak = FALSE;
|
|
|
|
static BOOL LogCancel = FALSE;
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| ErrorResetAll()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void ErrorResetAll() {
|
|
ErrorFlag = FALSE;
|
|
CategoryWritten = FALSE;
|
|
ContextWritten = FALSE;
|
|
CategorySet = FALSE;
|
|
ItemSet = FALSE;
|
|
|
|
lstrcpy(ErrorContext, TEXT(""));
|
|
lstrcpy(ErrorCategory, TEXT(""));
|
|
|
|
} // ErrorResetAll
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| ErrorContextSet()
|
|
|
|
|
| Sets the context for the error message, generally this would be
|
|
| the source and destination server pair.
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void ErrorContextSet(LPTSTR szFormat, ...) {
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
wvsprintf(ErrorContext, szFormat, marker);
|
|
|
|
// Do category and item as well since context is higher level
|
|
lstrcpy(ErrorCategory, TEXT(""));
|
|
lstrcpy(ErrorItem, TEXT(""));
|
|
|
|
ContextWritten = FALSE;
|
|
CategoryWritten = FALSE;
|
|
va_end(marker);
|
|
|
|
} // ErrorContextSet
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| ErrorCategorySet()
|
|
|
|
|
| Sets the category for the error message, generally this would tell
|
|
| what type of items is being converted: "Converting Users"
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void ErrorCategorySet(LPTSTR szFormat, ...) {
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
wvsprintf(ErrorCategory, szFormat, marker);
|
|
CategorySet = TRUE;
|
|
ItemSet = FALSE;
|
|
lstrcpy(ErrorItem, TEXT(""));
|
|
CategoryWritten = FALSE;
|
|
va_end(marker);
|
|
|
|
} // ErrorCategorySet
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| ErrorItemSet()
|
|
|
|
|
| Defines the specific item that error'd. This is usually a user,
|
|
| group or file name.
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void ErrorItemSet(LPTSTR szFormat, ...) {
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
ItemSet = TRUE;
|
|
wvsprintf(ErrorItem, szFormat, marker);
|
|
va_end(marker);
|
|
|
|
} // ErrorItemSet
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| ErrorReset()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void ErrorReset() {
|
|
ErrorFlag = FALSE;
|
|
lstrcpy(ErrorText, TEXT(""));
|
|
|
|
} // ErrorReset
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| ErrorSet()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void ErrorSet(LPTSTR szFormat, ...) {
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
wvsprintf(ErrorText, szFormat, marker);
|
|
ErrorFlag = TRUE;
|
|
va_end(marker);
|
|
|
|
} // ErrorSet
|
|
|
|
|
|
BOOL ErrorOccured() {
|
|
return ErrorFlag;
|
|
|
|
} // ErrorOccured
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| ErrorBox()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void ErrorBox(LPTSTR szFormat, ...) {
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
wvsprintf(ErrorText, szFormat, marker);
|
|
|
|
MessageBeep(MB_ICONASTERISK);
|
|
MessageBox(NULL, ErrorText, (LPTSTR) Lids(IDS_E_2), MB_TASKMODAL | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
va_end(marker);
|
|
} // ErrorBox
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| ErrorBoxRetry()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
int ErrorBoxRetry(LPTSTR szFormat, ...) {
|
|
int ret;
|
|
LPVOID lpMessageBuffer;
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
wvsprintf(ErrorText, szFormat, marker);
|
|
|
|
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL, GetLastError(), 0,
|
|
(LPTSTR) &lpMessageBuffer, 0, NULL );
|
|
|
|
MessageBeep(MB_ICONASTERISK);
|
|
ret = MessageBox(NULL, (LPTSTR) lpMessageBuffer, ErrorText,
|
|
MB_TASKMODAL | MB_ICONEXCLAMATION | MB_RETRYCANCEL);
|
|
LocalFree(lpMessageBuffer);
|
|
|
|
va_end(marker);
|
|
|
|
return ret;
|
|
} // ErrorBoxRetry
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| FileOpenBackup()
|
|
|
|
|
| Tries to open a file, if it already exists then creates a backup
|
|
| with the extension in the form (.001 to .999). It tries .001 first
|
|
| and if already used then tries .002, etc...
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
HANDLE FileOpenBackup(CHAR *FileRoot, CHAR *FileExt) {
|
|
int ret;
|
|
HANDLE hFile = NULL;
|
|
DWORD dwFileNumber;
|
|
char FileName[MAX_PATH + 1];
|
|
char buffer[MAX_PATH + 1];
|
|
TCHAR FileNameW[MAX_PATH + 1];
|
|
|
|
wsprintfA(FileName, "%s%s", FileRoot, FileExt);
|
|
|
|
// Open, but fail if already exists.
|
|
hFile = CreateFileA( FileName, GENERIC_READ | GENERIC_WRITE, 0,
|
|
NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
|
|
// Check if Error - file exists
|
|
if(hFile == INVALID_HANDLE_VALUE) {
|
|
dwFileNumber = 0;
|
|
|
|
// Find next backup number...
|
|
// Files are backed up as .xxx where xxx is a number in the form .001,
|
|
// the first backup is stored as .001, second as .002, etc...
|
|
do {
|
|
dwFileNumber++;
|
|
wsprintfA(FileName, "%s%03u", FileRoot, dwFileNumber);
|
|
|
|
hFile = CreateFileA( FileName, GENERIC_READ, 0, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
if (hFile != (HANDLE) INVALID_HANDLE_VALUE)
|
|
CloseHandle( hFile );
|
|
|
|
} while ( (hFile != INVALID_HANDLE_VALUE) );
|
|
|
|
// Rename the last log file to the first available number
|
|
wsprintfA( buffer, "%s%s", FileRoot, FileExt);
|
|
MoveFileA( buffer, FileName);
|
|
|
|
lstrcpyA(FileName, buffer);
|
|
// Create the new log file
|
|
hFile = CreateFileA( FileName, GENERIC_READ | GENERIC_WRITE, 0,
|
|
NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
|
|
|
|
if (hFile != (HANDLE) INVALID_HANDLE_VALUE)
|
|
CloseHandle( hFile );
|
|
|
|
} else
|
|
CloseHandle(hFile);
|
|
|
|
wsprintfA(FileName, "%s%s", FileRoot, FileExt);
|
|
|
|
// Now do the actual creation with error handling...
|
|
do {
|
|
ret = IDOK;
|
|
hFile = CreateFileA( FileName, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL );
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE) {
|
|
MultiByteToWideChar(CP_ACP, 0, FileName, -1, FileNameW, sizeof(FileNameW) );
|
|
ret = ErrorBoxRetry(Lids(IDS_E_13), FileNameW);
|
|
}
|
|
|
|
} while(ret == IDRETRY);
|
|
|
|
return(hFile);
|
|
|
|
} // FileOpenBackup
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| GetTime()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void GetTime(TCHAR *str) {
|
|
SYSTEMTIME st;
|
|
static TCHAR *aszDay[7];
|
|
|
|
aszDay[0] = Lids(IDS_SUNDAY);
|
|
aszDay[1] = Lids(IDS_MONDAY);
|
|
aszDay[2] = Lids(IDS_TUESDAY);
|
|
aszDay[3] = Lids(IDS_WEDNESDAY);
|
|
aszDay[4] = Lids(IDS_THURSDAY);
|
|
aszDay[5] = Lids(IDS_FRIDAY);
|
|
aszDay[6] = Lids(IDS_SATURDAY);
|
|
|
|
GetLocalTime(&st);
|
|
|
|
wsprintf(str, TEXT("%s, %02u/%02u/%4u (%02u:%02u:%02u)"),
|
|
aszDay[st.wDayOfWeek], st.wMonth,
|
|
st.wDay, st.wYear,
|
|
st.wHour, st.wMinute, st.wSecond);
|
|
} // GetTime
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| WriteLog()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
DWORD WriteLog(HANDLE hFile, int Level, LPTSTR String) {
|
|
int ret;
|
|
DWORD wrote;
|
|
static char tmpStr[MAX_LOG_STR];
|
|
static char LogStr[MAX_LOG_STR];
|
|
|
|
// If the user canceled writing to the log, then don't keep trying
|
|
if (LogCancel)
|
|
return 1;
|
|
|
|
// Put ending NULL at correct place
|
|
Spaces[Level * 3] = '\0';
|
|
|
|
// Build up indented ANSI string to write out
|
|
lstrcpyA(tmpStr, Spaces);
|
|
WideCharToMultiByte(CP_ACP, 0, String, -1, LogStr, sizeof(LogStr), NULL, NULL);
|
|
lstrcatA(tmpStr, LogStr);
|
|
|
|
// reset for later writes
|
|
Spaces[Level * 3] = ' ';
|
|
|
|
|
|
// Now do the actual write with error handling...
|
|
do {
|
|
ret = IDOK;
|
|
|
|
if (!WriteFile(hFile, tmpStr, strlen(tmpStr), &wrote, NULL)) {
|
|
ret = ErrorBoxRetry(Lids(IDS_E_NWLOG));
|
|
}
|
|
|
|
} while(ret == IDRETRY);
|
|
|
|
if (ret == IDCANCEL) {
|
|
LogCancel = TRUE;
|
|
return 1;
|
|
}
|
|
else
|
|
return 0;
|
|
|
|
} // WriteLog
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| LogHeader()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void LogHeader(HANDLE hFile, TCHAR *Title) {
|
|
DWORD ret;
|
|
DWORD wrote;
|
|
static TCHAR time[40];
|
|
static TCHAR tmpStr[MAX_LOG_STR];
|
|
static TCHAR tmpStr2[MAX_LOG_STR];
|
|
static TCHAR *line;
|
|
|
|
ret = WriteLog(hFile, 0, Lids(IDS_LINE));
|
|
wsprintf(tmpStr, Lids(IDS_BRACE), Title);
|
|
|
|
if (!ret)
|
|
ret = WriteLog(hFile, 0, tmpStr);
|
|
|
|
if (!ret)
|
|
ret = WriteLog(hFile, 0, Lids(IDS_LINE));
|
|
|
|
GetTime(time);
|
|
wsprintf(tmpStr, Lids(IDS_L_97), time);
|
|
|
|
if (!ret)
|
|
ret = WriteLog(hFile, 0, tmpStr);
|
|
|
|
wrote = sizeof(tmpStr2);
|
|
GetComputerName(tmpStr2, &wrote);
|
|
wsprintf(tmpStr, Lids(IDS_L_98), tmpStr2);
|
|
|
|
if (!ret)
|
|
WriteLog(hFile, 0, tmpStr);
|
|
|
|
wrote = sizeof(tmpStr);
|
|
WNetGetUser(NULL, tmpStr2, &wrote);
|
|
wsprintf(tmpStr, Lids(IDS_L_99), tmpStr2);
|
|
|
|
if (!ret)
|
|
ret = WriteLog(hFile, 0, tmpStr);
|
|
|
|
wsprintf(tmpStr, Lids(IDS_L_100), VER_HI, VER_LOW);
|
|
|
|
if (!ret)
|
|
ret = WriteLog(hFile, 0, tmpStr);
|
|
|
|
if (!ret)
|
|
ret = WriteLog(hFile, 0, Lids(IDS_LINE));
|
|
|
|
} // LogHeader
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| LogInit()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void LogInit() {
|
|
lstrcpyA(LogFileName, FILENAME_LOG);
|
|
lstrcpyA(ErrorLogFileName, FILENAME_ERROR);
|
|
lstrcpyA(SummaryLogFileName, FILENAME_SUMMARY);
|
|
|
|
LogCancel = FALSE;
|
|
|
|
hErr = FileOpenBackup(ERR_FILENAME, STD_EXT);
|
|
hLog = FileOpenBackup(LOG_FILENAME, STD_EXT);
|
|
hSummary = FileOpenBackup(SUMMARY_FILENAME, STD_EXT);
|
|
|
|
LogHeader(hErr, Lids(IDS_L_101));
|
|
CloseHandle(hErr);
|
|
|
|
LogHeader(hLog, Lids(IDS_L_102));
|
|
CloseHandle(hLog);
|
|
|
|
LogHeader(hSummary, Lids(IDS_L_103));
|
|
CloseHandle(hSummary);
|
|
|
|
} // LogInit
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| LogWriteLog()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void LogWriteLog(int Level, LPTSTR szFormat, ...) {
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
wvsprintf(tmpStr, szFormat, marker);
|
|
|
|
hLog = CreateFileA( LogFileName, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
SetFilePointer(hLog, 0, NULL, FILE_END);
|
|
WriteLog(hLog, Level, tmpStr);
|
|
CloseHandle(hLog);
|
|
va_end(marker);
|
|
|
|
} // LogWriteLog
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| LogWritErr()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void LogWriteErr(LPTSTR szFormat, ...) {
|
|
int Indent = 3;
|
|
DWORD wrote;
|
|
static char LogStr[MAX_LOG_STR];
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
wvsprintf(tmpStr, szFormat, marker);
|
|
|
|
hErr = CreateFileA( ErrorLogFileName, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
SetFilePointer(hErr, 0, NULL, FILE_END);
|
|
|
|
if (!ContextWritten) {
|
|
ContextWritten = TRUE;
|
|
WideCharToMultiByte(CP_ACP, 0, ErrorContext, -1, LogStr, sizeof(LogStr), NULL, NULL);
|
|
WriteFile(hErr, LogStr, strlen(LogStr), &wrote, NULL);
|
|
}
|
|
|
|
if (CategorySet && !CategoryWritten) {
|
|
CategoryWritten = TRUE;
|
|
Spaces[3] = '\0';
|
|
WriteFile(hLog, Spaces, strlen(Spaces), &wrote, NULL);
|
|
WideCharToMultiByte(CP_ACP, 0, ErrorCategory, -1, LogStr, sizeof(LogStr), NULL, NULL);
|
|
WriteFile(hErr, LogStr, strlen(LogStr), &wrote, NULL);
|
|
Spaces[3] = ' ';
|
|
}
|
|
|
|
if (ItemSet) {
|
|
Spaces[6] = '\0';
|
|
WriteFile(hLog, Spaces, strlen(Spaces), &wrote, NULL);
|
|
WideCharToMultiByte(CP_ACP, 0, ErrorItem, -1, LogStr, sizeof(LogStr), NULL, NULL);
|
|
WriteFile(hErr, LogStr, strlen(LogStr), &wrote, NULL);
|
|
Spaces[6] = ' ';
|
|
}
|
|
|
|
if (CategorySet)
|
|
Indent +=3;
|
|
|
|
if (ItemSet)
|
|
Indent +=3;
|
|
|
|
Spaces[Indent] = '\0';
|
|
WriteFile(hLog, Spaces, strlen(Spaces), &wrote, NULL);
|
|
WideCharToMultiByte(CP_ACP, 0, tmpStr, -1, LogStr, sizeof(LogStr), NULL, NULL);
|
|
WriteFile(hErr, LogStr, strlen(LogStr), &wrote, NULL);
|
|
Spaces[Indent] = ' ';
|
|
CloseHandle(hErr);
|
|
va_end(marker);
|
|
|
|
} // LogWriteErr
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| LogWriteSummary()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void LogWriteSummary(int Level, LPTSTR szFormat, ...) {
|
|
DWORD wrote;
|
|
static char LogStr[MAX_LOG_STR];
|
|
va_list marker;
|
|
|
|
va_start(marker, szFormat);
|
|
Spaces[Level * 3] = '\0';
|
|
wvsprintf(tmpStr, szFormat, marker);
|
|
WideCharToMultiByte(CP_ACP, 0, tmpStr, -1, LogStr, sizeof(LogStr), NULL, NULL);
|
|
|
|
hSummary = CreateFileA( SummaryLogFileName, GENERIC_WRITE, 0,
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
SetFilePointer(hSummary, 0, NULL, FILE_END);
|
|
WriteFile(hLog, Spaces, strlen(Spaces), &wrote, NULL);
|
|
WriteFile(hSummary, LogStr, strlen(LogStr), &wrote, NULL);
|
|
Spaces[Level * 3] = ' ';
|
|
CloseHandle(hSummary);
|
|
va_end(marker);
|
|
|
|
} // LogWriteSummary
|
|
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| DlgLogging()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
LRESULT CALLBACK DlgLogging(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
|
|
HANDLE hFile;
|
|
static BOOL UserLogging, FileLogging, ErrorFlag;
|
|
int wmId, wmEvent;
|
|
static char CmdLine[256];
|
|
HWND hCtrl;
|
|
|
|
switch (message) {
|
|
case WM_INITDIALOG:
|
|
// Center the dialog over the application window
|
|
CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER));
|
|
|
|
// Toggle User Logging Control
|
|
UserLogging = VerboseULogging;
|
|
hCtrl = GetDlgItem(hDlg, IDC_CHKUVERBOSE);
|
|
if (VerboseULogging)
|
|
SendMessage(hCtrl, BM_SETCHECK, 1, 0);
|
|
else
|
|
SendMessage(hCtrl, BM_SETCHECK, 0, 0);
|
|
|
|
// Toggle File Logging Control
|
|
FileLogging = VerboseFLogging;
|
|
hCtrl = GetDlgItem(hDlg, IDC_CHKFVERBOSE);
|
|
if (VerboseFLogging)
|
|
SendMessage(hCtrl, BM_SETCHECK, 1, 0);
|
|
else
|
|
SendMessage(hCtrl, BM_SETCHECK, 0, 0);
|
|
|
|
// Toggle Error Popup Control
|
|
ErrorFlag = ErrorBreak;
|
|
hCtrl = GetDlgItem(hDlg, IDC_CHKERROR);
|
|
if (ErrorBreak)
|
|
SendMessage(hCtrl, BM_SETCHECK, 1, 0);
|
|
else
|
|
SendMessage(hCtrl, BM_SETCHECK, 0, 0);
|
|
|
|
hCtrl = GetDlgItem(hDlg, IDC_VIEWLOG);
|
|
|
|
// check if logfile exists, if it does allow log file viewing...
|
|
hFile = CreateFileA( FILENAME_LOG, GENERIC_READ, 0, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
if (hFile != (HANDLE) INVALID_HANDLE_VALUE)
|
|
CloseHandle( hFile );
|
|
else
|
|
EnableWindow(hCtrl, FALSE);
|
|
|
|
return (TRUE);
|
|
|
|
case WM_COMMAND:
|
|
wmId = LOWORD(wParam);
|
|
wmEvent = HIWORD(wParam);
|
|
|
|
switch (wmId) {
|
|
case IDOK:
|
|
VerboseULogging = UserLogging;
|
|
VerboseFLogging = FileLogging;
|
|
ErrorBreak = ErrorFlag;
|
|
EndDialog(hDlg, 0);
|
|
return (TRUE);
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, 0);
|
|
return (TRUE);
|
|
|
|
case IDHELP:
|
|
WinHelp(hDlg, HELP_FILE, HELP_CONTEXT, (DWORD) IDC_HELP_LOGGING);
|
|
break;
|
|
|
|
case IDC_VIEWLOG:
|
|
lstrcpyA(CmdLine, "LogView ");
|
|
lstrcatA(CmdLine, "Error.LOG Summary.LOG LogFile.LOG");
|
|
WinExec(CmdLine, SW_SHOW);
|
|
return (TRUE);
|
|
break;
|
|
|
|
case IDC_CHKUVERBOSE:
|
|
UserLogging = !UserLogging;
|
|
return (TRUE);
|
|
break;
|
|
|
|
case IDC_CHKFVERBOSE:
|
|
FileLogging = !FileLogging;
|
|
return (TRUE);
|
|
break;
|
|
|
|
case IDC_CHKERROR:
|
|
ErrorFlag = !ErrorFlag;
|
|
return (TRUE);
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return (FALSE); // Didn't process the message
|
|
|
|
lParam;
|
|
} // DlgLogging
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| LogOptionsInit()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void LogOptionsInit() {
|
|
ErrorBreak = FALSE;
|
|
VerboseULogging = TRUE;
|
|
VerboseFLogging = FALSE;
|
|
} // LogOptionsInit
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| LogOptionsSave()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void LogOptionsSave( HANDLE hFile ) {
|
|
DWORD wrote;
|
|
|
|
WriteFile(hFile, &ErrorBreak, sizeof(ErrorBreak), &wrote, NULL);
|
|
WriteFile(hFile, &VerboseFLogging, sizeof(VerboseFLogging), &wrote, NULL);
|
|
WriteFile(hFile, &VerboseULogging, sizeof(VerboseULogging), &wrote, NULL);
|
|
} // LogOptionsSave
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| LogOptionsLoad()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void LogOptionsLoad( HANDLE hFile ) {
|
|
DWORD wrote;
|
|
|
|
ReadFile(hFile, &ErrorBreak, sizeof(ErrorBreak), &wrote, NULL);
|
|
ReadFile(hFile, &VerboseFLogging, sizeof(VerboseFLogging), &wrote, NULL);
|
|
ReadFile(hFile, &VerboseULogging, sizeof(VerboseULogging), &wrote, NULL);
|
|
|
|
#ifdef DEBUG
|
|
dprintf(TEXT("<Log Options Load>\n"));
|
|
dprintf(TEXT(" Error Break: %lx\n"), ErrorBreak);
|
|
dprintf(TEXT(" Verbose File Logging: %lx\n"), VerboseFLogging);
|
|
dprintf(TEXT(" Verbose User Logging: %lx\n\n"), VerboseULogging);
|
|
#endif
|
|
} // LogOptionsLoad
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| PopupOnError()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
BOOL PopupOnError() {
|
|
return ErrorBreak;
|
|
|
|
} // PopupOnError
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| VerboseFileLogging()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
BOOL VerboseFileLogging() {
|
|
return VerboseFLogging;
|
|
|
|
} // VerboseFileLogging
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| VerboseUserLogging()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
BOOL VerboseUserLogging() {
|
|
return VerboseULogging;
|
|
|
|
} // VerboseUserLogging
|
|
|
|
|
|
/*+-------------------------------------------------------------------------+
|
|
| DoLoggingDlg()
|
|
|
|
|
+-------------------------------------------------------------------------+*/
|
|
void DoLoggingDlg(HWND hDlg) {
|
|
DLGPROC lpfnDlg;
|
|
|
|
lpfnDlg = MakeProcInstance((DLGPROC)DlgLogging, hInst);
|
|
DialogBox(hInst, TEXT("DlgLogging"), hDlg, lpfnDlg) ;
|
|
FreeProcInstance(lpfnDlg);
|
|
|
|
} // DoLoggingDlg
|