//--------------------------------------------------------------------------
// LogFile.cpp
// Copyright (C) Microsoft Corporation, 1997 - Rocket Database
//--------------------------------------------------------------------------
#include "pch.hxx"
#include <stdio.h>
#include <time.h>
#include <winver.h>
#include "clogfile.h"
#include <shlwapi.h>
#include <demand.h>
#include <BadStrFunctions.h>

//--------------------------------------------------------------------------
// LogFileTypes - RX = Receive, TX = Transmit, DB = Debug
//--------------------------------------------------------------------------
static LPSTR s_rgszPrefix[LOGFILE_MAX] = {
    "rx",
    "tx",
    "db"
};

//--------------------------------------------------------------------------
// These are strings that we shouldn't log in plaintext
//--------------------------------------------------------------------------
static LPSTR s_rgszPassPrefix[] = {
    "AUTHINFO PASS ",
    "PASS ",
    NULL
};

//--------------------------------------------------------------------------
// CreateSystemHandleName
//--------------------------------------------------------------------------
HRESULT CreateSystemHandleName(LPCSTR pszBase, LPCSTR pszSpecific, 
    LPSTR *ppszName)
{
    // Locals
    HRESULT     hr=S_OK;
    DWORD       cchName;

    // Trace
    TraceCall("CreateSystemHandleName");

    // Invalid Args
    Assert(pszBase && pszSpecific && ppszName);

    // Init
    *ppszName = NULL;

    // Compute Length
    cchName = lstrlen(pszBase) + lstrlen(pszSpecific) + 15;

    // Allocate
    IF_NULLEXIT(*ppszName = PszAllocA(cchName));

    // Format the name
    wnsprintf(*ppszName, cchName, "%s%s", pszBase, pszSpecific);

    // Remove backslashes from this string
    ReplaceChars(*ppszName, '\\', '_');

    // Lower Case
    CharLower(*ppszName);

exit:
    // Done
    return hr;
}

//--------------------------------------------------------------------------
// CreateLogFile
//--------------------------------------------------------------------------
OESTDAPI_(HRESULT) CreateLogFile(HINSTANCE hInst, LPCSTR pszLogFile, 
    LPCSTR pszPrefix, DWORD cbTruncate, ILogFile **ppLogFile,
    DWORD dwShareMode)
{
    // Locals
    HRESULT     hr=S_OK;
    CLogFile   *pNew=NULL;

    // Trace
    TraceCall("CreateLogFile");

    // Invalid Args
    Assert(ppLogFile && pszLogFile);

    // Initialize
    *ppLogFile = NULL;

    // Create me
    pNew = new CLogFile;
    if (NULL == pNew)
    {
        hr = TraceResult(E_OUTOFMEMORY);
        goto exit;
    }

    // Open It
    IF_FAILEXIT(hr = pNew->Open(hInst, pszLogFile, pszPrefix, cbTruncate, dwShareMode));

    // Open It
    *ppLogFile = (ILogFile *)pNew;

    // Don't release it
    pNew = NULL;

exit:
    // Cleanup
    SafeRelease(pNew);

    // Done
    return hr;
}

//--------------------------------------------------------------------------
// CLogFile::CLogFile
//--------------------------------------------------------------------------
CLogFile::CLogFile(void)
{
    TraceCall("CLogFile::CLogFile");
    m_cRef = 1;
    m_hMutex = NULL;
    m_hFile = INVALID_HANDLE_VALUE;
    InitializeCriticalSection(&m_cs);
}

//--------------------------------------------------------------------------
// CLogFile::~CLogFile
//--------------------------------------------------------------------------
CLogFile::~CLogFile(void)
{
    TraceCall("CLogFile::~CLogFile");
    if (m_hFile != INVALID_HANDLE_VALUE)
        CloseHandle_F16(m_hFile);
    SafeCloseHandle(m_hMutex);
    DeleteCriticalSection(&m_cs);
}

//--------------------------------------------------------------------------
// CLogFile::AddRef
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CLogFile::AddRef(void)
{
    TraceCall("CLogFile::AddRef");
    return InterlockedIncrement(&m_cRef);
}

//--------------------------------------------------------------------------
// CLogFile::Release
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CLogFile::Release(void)
{
    TraceCall("CLogFile::Release");
    LONG cRef = InterlockedDecrement(&m_cRef);
    if (0 == cRef)
        delete this;
    return (ULONG)cRef;
}

//--------------------------------------------------------------------------
// CLogFile::QueryInterface
//--------------------------------------------------------------------------
STDMETHODIMP CLogFile::QueryInterface(REFIID riid, LPVOID *ppv)
{
    // Locals
    HRESULT     hr=S_OK;

    // Stack
    TraceCall("CLogFile::QueryInterface");

    // Find IID
    if (IID_IUnknown == riid)
        *ppv = (IUnknown *)this;
    else
    {
        *ppv = NULL;
        hr = TraceResult(E_NOINTERFACE);
        goto exit;
    }

    // AddRef It
    ((IUnknown *)*ppv)->AddRef();

exit:
    // Done
    return hr;
}

//--------------------------------------------------------------------------
// CLogFile::Open
//--------------------------------------------------------------------------
STDMETHODIMP CLogFile::Open(HINSTANCE hInst, LPCSTR pszFile, LPCSTR pszPrefix,
                            DWORD cbTruncate, DWORD dwShareMode)
{   
    // Locals
    HRESULT         hr=S_OK;
    CHAR            szVersion[MAX_PATH];
    CHAR            szPath[MAX_PATH];
    LPSTR           pszInfo=NULL;
    DWORD           dwVerHnd;
    DWORD           dwVerInfoSize;
    DWORD           cbFile;
    CHAR            szGet[MAX_PATH];
    UINT            uLen;
    LPWORD          pdwTrans;
    LPSTR           pszT;
    SYSTEMTIME      st;
    LPSTR           pszVersion;
    CHAR            szPathMinusExt[MAX_PATH + 2];
    CHAR            szExt[4];
    DWORD           dwBytesWritten;
    LPSTR           pszMutex=NULL;
    BOOL            fReleaseMutex=FALSE;
    int             iCurrentLogNum; // For unique logfile generation

    // Tracing
    TraceCall("CLogFile::Open");

    // Save the Prefix
    StrCpyN(m_szPrefix, pszPrefix ? pszPrefix : "", ARRAYSIZE(m_szPrefix));

    // Create a Mutex Name
    IF_FAILEXIT(hr = CreateSystemHandleName(pszFile, "logfile", &pszMutex));

    // Create the Mutex
    m_hMutex = CreateMutex(NULL, FALSE, pszMutex);
    if (m_hMutex == NULL)
    {
        hr = TraceResult(E_FAIL);
        goto exit;
    }

    // If we have a mutex
    if (WAIT_OBJECT_0 != WaitForSingleObject(m_hMutex, INFINITE))
    {
        hr = TraceResult(E_FAIL);
        goto exit;
    }

    // Release the Mutex
    fReleaseMutex = TRUE;

    // Split the logfile into path+filename and extension
    iCurrentLogNum = 0;
    StrCpyN(szPathMinusExt, pszFile, ARRAYSIZE(szPathMinusExt));
    pszT = PathFindExtension(szPathMinusExt);
    if (pszT && '.' == *pszT)
    {
        StrCpyN(szExt, pszT + 1, ARRAYSIZE(szExt));
        *pszT = '\0'; // Remove extension from path and filename
    }
    else
    {
        // Use default extension of "log"
        StrCpyN(szExt, "log", ARRAYSIZE(szExt));
    }

    // Generate first logfile name
    wnsprintf(szPath, ARRAYSIZE(szPath), "%s.%s", szPathMinusExt, szExt);

    // Open|Create the log file
    do
    {
        m_hFile = CreateFile(szPath, GENERIC_WRITE, dwShareMode, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (INVALID_HANDLE_VALUE == m_hFile)
        {
            DWORD dwLastErr;

            dwLastErr = GetLastError();
            // If file is already in use, then try to create a separate logfile. Otherwise bail.
            if (ERROR_SHARING_VIOLATION == dwLastErr)
            {
                // Generate next unique file name
                iCurrentLogNum += 1;
                wnsprintf(szPath, ARRAYSIZE(szPath), "%s (%d).%s", szPathMinusExt, iCurrentLogNum, szExt);
            }
            else
            {
                hr = TraceResultSz(E_FAIL, _MSG("Can't open logfile %s, GetLastError() = %d", szPath, dwLastErr));
                goto exit;
            }
        }
    } while (INVALID_HANDLE_VALUE == m_hFile);

    // Get the File Size
    cbFile = GetFileSize(m_hFile, NULL);

    // Get the size of the file    
    if (0xFFFFFFFF != cbFile) 
    {
        // Truncate It
        if (cbFile >= cbTruncate)
        {
            // Set the file pointer to the end of the file
            if (0xFFFFFFFF == SetFilePointer(m_hFile, 0, NULL, FILE_BEGIN))
            {
                Assert(FALSE);
                hr = TraceResult(E_FAIL);
                goto exit;
            }

            // Set the End of file
            if (0 == SetEndOfFile(m_hFile))
            {
                Assert(FALSE);
                hr = TraceResult(E_FAIL);
                goto exit;
            }

            // File is zero-length
            cbFile = 0;
        }

        // Set the file pointer to the end of the file
        if (0xFFFFFFFF == SetFilePointer(m_hFile, 0, NULL, FILE_END))
        {
            Assert(FALSE);
            hr = TraceResultSz(E_FAIL, _MSG("Can't seek to the end of the logfile %s, GetLastError() = %d", szPath, GetLastError()));
            goto exit;
        }
    }

    // Get Module FileName
	GetModuleFileName(hInst, szPath, sizeof(szPath));

    // Initialize szVersion
    szVersion[0] = '\0';

	// Get version information from athena
	dwVerInfoSize = GetFileVersionInfoSize(szPath, &dwVerHnd);
    if (dwVerInfoSize)
    {
        // Allocate
        IF_NULLEXIT(pszInfo = (LPSTR)g_pMalloc->Alloc(dwVerInfoSize));

        // Get version info
	    if (GetFileVersionInfo(szPath, dwVerHnd, dwVerInfoSize, pszInfo))
        {
            // VerQueryValue
            if (VerQueryValue(pszInfo, "\\VarFileInfo\\Translation", (LPVOID *)&pdwTrans, &uLen) && uLen >= (2 * sizeof(WORD)))
            {
                // set up buffer for calls to VerQueryValue()
                wnsprintf(szGet, ARRAYSIZE(szGet), "\\StringFileInfo\\%04X%04X\\", pdwTrans[0], pdwTrans[1]);

                // What is this doing
                DWORD cchLen = lstrlen(szGet);
                pszT = szGet + cchLen;

                // Setup file description
                StrCatBuff(szGet, "FileDescription", ARRAYSIZE(szGet));

                // Get the file description
                if (VerQueryValue(pszInfo, szGet, (LPVOID *)&pszVersion, &uLen) && uLen)
                {                                    
                    StrCpyN(szVersion, pszVersion, ARRAYSIZE(szVersion));
                    StrCatBuff(szVersion, " ", ARRAYSIZE(szVersion));
                }

                // Setup Version String
                StrCpyN(pszT, "FileVersion", ARRAYSIZE(szGet) - cchLen);

                // Get the file version
                if (VerQueryValue(pszInfo, szGet, (LPVOID *)&pszVersion, &uLen) && uLen)
                    StrCatBuff(szVersion, pszVersion, ARRAYSIZE(szVersion));
            }
        }
    }

    // Write the Date
    GetLocalTime(&st);
    wnsprintf(szPath, ARRAYSIZE(szPath), "\r\n%s\r\n%s Log started at %.2d/%.2d/%.4d %.2d:%.2d:%.2d\r\n", szVersion, pszPrefix, st.wMonth, st.wDay, st.wYear, st.wHour, st.wMinute, st.wSecond);

    // add a new line
    WriteFile(m_hFile, szPath, lstrlen(szPath), &dwBytesWritten, NULL);

exit:
    // Failure
    AssertSz(SUCCEEDED(hr), "Log file could not be opened.");

    // Cleanup
    if (fReleaseMutex)
        ReleaseMutex(m_hMutex);
    SafeMemFree(pszInfo);
    SafeMemFree(pszMutex);

    // Done
    return hr;
}

//--------------------------------------------------------------------------
// WriteLogMsg
//--------------------------------------------------------------------------
STDMETHODIMP WriteLogMsg(CLogFile *pLogFile, LOGFILETYPE lft, LPTSTR pszFormat, ...)
{
    static TCHAR szBuffer[2048];
    va_list arglist;

    va_start(arglist, pszFormat);
    wvnsprintf(szBuffer, ARRAYSIZE(szBuffer), pszFormat, arglist);
    va_end(arglist);

    return pLogFile->WriteLog(lft, szBuffer);
}

//--------------------------------------------------------------------------
// CLogFile::TraceLog
//--------------------------------------------------------------------------
STDMETHODIMP CLogFile::TraceLog(SHOWTRACEMASK dwMask, TRACEMACROTYPE tracetype, ULONG ulLine, HRESULT hrResult, LPCSTR pszMessage)
{
    // Write the message
    if (TRACE_INFO == tracetype && pszMessage)
    {
        if (ISFLAGSET(dwMask, SHOW_TRACE_INFO))
            WriteLogMsg(this, LOGFILE_DB, "0x%08X: L(%d), Info: %s", GetCurrentThreadId(), ulLine, pszMessage);
    }
    else if (TRACE_RESULT == tracetype && pszMessage)
        WriteLogMsg(this, LOGFILE_DB, "0x%08X: L(%d), Result: HRESULT(0x%08X) - GetLastError() = %d - %s", GetCurrentThreadId(), ulLine, hrResult, GetLastError(), pszMessage);
    else if (TRACE_RESULT == tracetype && NULL == pszMessage)
        WriteLogMsg(this, LOGFILE_DB, "0x%08X: L(%d), Result: HRESULT(0x%08X) - GetLastError() = %d", GetCurrentThreadId(), ulLine, hrResult, GetLastError());
    else
        Assert(FALSE);

    // Done
    return hrResult;
}

//--------------------------------------------------------------------------
// CLogFile::WriteLog
//--------------------------------------------------------------------------
STDMETHODIMP CLogFile::WriteLog(LOGFILETYPE lft, LPCSTR pszData)
{
    // Locals
    HRESULT     hr=S_OK;
    DWORD       bWrite;
    DWORD       cBytesWritten;
    SYSTEMTIME  st;
    CHAR        szLogPrefx[30];
    INT         cb;
    LPSTR       *ppszPrefix;
    LPSTR       pszFree=NULL;
    BOOL        fReleaseMutex=FALSE;

    // Trace
    TraceCall("CLogFile::WriteLog");

    // File is not open
    if (m_hFile == INVALID_HANDLE_VALUE)
        return TraceResult(E_UNEXPECTED);

    // Invalid Args
    Assert(pszData && lft < LOGFILE_MAX);

    // Thread Safety
    EnterCriticalSection(&m_cs);

    // Initialized
    Assert(m_hMutex);

    // If we have a mutex
    if (WAIT_OBJECT_0 != WaitForSingleObject(m_hMutex, INFINITE))
    {
        hr = TraceResult(E_FAIL);
        goto exit;
    }

    // Release the Mutex
    fReleaseMutex = TRUE;

    // Get the time
    GetLocalTime(&st);
    
    // Write the log prefix and time stamp
    wnsprintf(szLogPrefx, ARRAYSIZE(szLogPrefx), "%s: %.2d:%.2d:%.2d [%s] ", m_szPrefix, st.wHour, st.wMinute, st.wSecond, s_rgszPrefix[lft]);

    // Set the file pointer to the end of the file (otherwise multiple writers overwrite each other)
    if (0xFFFFFFFF == SetFilePointer(m_hFile, 0, NULL, FILE_END))
    {
        hr = TraceResult(E_FAIL);
        goto exit;
    }

    // Write the time and prefix
    if (0 == WriteFile(m_hFile, szLogPrefx, lstrlen(szLogPrefx), &cBytesWritten, NULL))
    {
        hr = TraceResultSz(E_FAIL, _MSG("Can't write to logfile. GetLastError() = %d", GetLastError()));
        goto exit;
    }

    // Loop through prefixes
    for (ppszPrefix = s_rgszPassPrefix; *ppszPrefix; ppszPrefix++)
    {
        // Does the data start with one of these prefixes
        if (0 == StrCmpNI(pszData, *ppszPrefix, lstrlen(*ppszPrefix)))
        {
            // Dup the buffer that was passed in
            IF_NULLEXIT(pszFree = PszDupA(pszData));

            // Reset pszData
            pszData = pszFree;

            // Fixup the buffer
            for (LPSTR pszTmp = (LPSTR)pszData + lstrlen(*ppszPrefix); *pszTmp && *pszTmp != '\r'; pszTmp++)
                *pszTmp = '*';

            // Done
            break;
        }
    }

    // Get the length of pszData
    cb = lstrlen(pszData);

    // write the log data
    if (0 == WriteFile(m_hFile, pszData, cb, &cBytesWritten, NULL))
    {
        hr = TraceResultSz(E_FAIL, _MSG("Can't write to logfile. GetLastError() = %d", GetLastError()));
        goto exit;
    }

    // Add a CRLF if not there already
    if (cb < 2 || pszData[cb-1] != '\n' || pszData[cb-2] != '\r')
        WriteFile(m_hFile, "\r\n", 2, &cBytesWritten, NULL);

exit:
    // Cleanup
    if (fReleaseMutex)
        ReleaseMutex(m_hMutex);

    // Thread Safety
    LeaveCriticalSection(&m_cs);

    // Cleanup
    SafeMemFree(pszFree);

    // Done
    return hr;
}

//--------------------------------------------------------------------------
// CLogFile::DebugLog
//--------------------------------------------------------------------------
STDMETHODIMP CLogFile::DebugLog(LPCSTR pszData)
{
    return WriteLog(LOGFILE_DB, pszData);
}

//--------------------------------------------------------------------------
// CLogFile::DebugLogs
//--------------------------------------------------------------------------
STDMETHODIMP CLogFile::DebugLogs(LPCSTR pszFormat, LPCSTR pszString)
{
    // Locals
    CHAR szBuffer[1024];

    // Build the String
    wnsprintf(szBuffer, ARRAYSIZE(szBuffer), pszFormat, pszString);

    // Call Debug Log
    return DebugLog(szBuffer);
}

//--------------------------------------------------------------------------
// CLogFile::DebugLogd
//--------------------------------------------------------------------------
STDMETHODIMP CLogFile::DebugLogd(LPCSTR pszFormat, INT d)
{
    // Locals
    CHAR szBuffer[1024];

    // Build the String
    wnsprintf(szBuffer, ARRAYSIZE(szBuffer), pszFormat, d);

    // Call Debug Log
    return DebugLog(szBuffer);
}