1 files changed, 746 insertions, 0 deletions

diff --git a/private/nw/convert/nwconv/nwlog.c b/private/nw/convert/nwconv/nwlog.c
new file mode 100644
index 000000000..fd88a56b0
--- /dev/null
+++ b/private/nw/convert/nwconv/nwlog.c
@@ -0,0 +1,746 @@
+/*
+  +-------------------------------------------------------------------------+
+  |                         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