utils.cpp

This ZIP archive includes the sources (and executable) for the FileTest utility, written by Ladisla

/*****************************************************************************/
/* Utils.cpp                              Copyright (c) Ladislav Zezula 2004 */
/*---------------------------------------------------------------------------*/
/* Description:                                                              */
/*---------------------------------------------------------------------------*/
/*   Date    Ver   Who  Comment                                              */
/* --------  ----  ---  -------                                              */
/* 05.01.04  1.00  Lad  The first version of Utils.cpp                       */
/*****************************************************************************/

#include "FileTest.h"
#include "resource.h"

DWORD Text2CreateDisposition(const TCHAR * szTemp)
{
    if(!_tcsicmp(szTemp, _T("CREATE_NEW")))
        return CREATE_NEW;
    if(!_tcsicmp(szTemp, _T("CREATE_ALWAYS")))
        return CREATE_ALWAYS;
    if(!_tcsicmp(szTemp, _T("OPEN_EXISTING")))
        return OPEN_EXISTING;
    if(!_tcsicmp(szTemp, _T("OPEN_ALWAYS")))
        return CREATE_NEW;
    if(!_tcsicmp(szTemp, _T("TRUNCATE_EXISTING")))
        return CREATE_NEW;

    return 0;
}

void CreateDisposition2Text(DWORD dwCreateDisposition, TCHAR * szBuffer)
{
    if(dwCreateDisposition == CREATE_NEW)
        _tcscpy(szBuffer, _T("CREATE_NEW"));
    if(dwCreateDisposition == CREATE_ALWAYS)
        _tcscpy(szBuffer, _T("CREATE_ALWAYS"));
    if(dwCreateDisposition == CREATE_NEW)
        _tcscpy(szBuffer, _T("OPEN_EXISTING"));
    if(dwCreateDisposition == OPEN_ALWAYS)
        _tcscpy(szBuffer, _T("OPEN_ALWAYS"));
    if(dwCreateDisposition == TRUNCATE_EXISTING)
        _tcscpy(szBuffer, _T("TRUNCATE_EXISTING"));
}

//-----------------------------------------------------------------------------
// 32-bit values support

DWORD DlgText2Hex32(HWND hDlg, UINT nIDCtrl)
{
    TCHAR szText[128];

    GetDlgItemText(hDlg, nIDCtrl, szText, _tsize(szText));
    return Text2Hex32(szText);
}


// Converts the string to long. this function was written because
// the builtin strtol does not work correctly (try to convert 0xAABBCCDD !!!)
DWORD Text2Hex32(const TCHAR * szText)
{
    DWORD acc = 0;
    int nDigit;

    while((nDigit = toupper(*szText++)) != 0)
    {
        // If the character is not an alphanumeric, break
        if(!isxdigit(nDigit))
            break;

        // Convert to digit
        nDigit -= _T('0');
        if(nDigit > 9)
            nDigit -= (_T('A') - _T('9') - 1);

        // Move the value to the next rank and add the digit
        acc *= 0x10;
        acc += nDigit;
    }
    return acc;
}

//-----------------------------------------------------------------------------
// 32-bit values support

void Hex2Text32(DWORD dwValue, TCHAR * szBuffer)
{
    _stprintf(szBuffer, _T("%08lX"), dwValue);
}

void Hex2DlgText32(HWND hDlg, UINT nIDCtrl, DWORD dwValue)
{
    TCHAR szText[128];

    Hex2Text32(dwValue, szText);
    SetDlgItemText(hDlg, nIDCtrl, szText);
}


//-----------------------------------------------------------------------------
// Pointer support

DWORD_PTR DlgText2HexPtr(HWND hDlg, UINT nIDCtrl)
{
    TCHAR szText[128];

    GetDlgItemText(hDlg, nIDCtrl, szText, _tsize(szText));
    return Text2HexPtr(szText);
}

// Converts the string to long. this function was written because
// the builtin strtol does not work correctly (try to convert 0xAABBCCDD !!!)
DWORD_PTR Text2HexPtr(const TCHAR * szText)
{
    DWORD_PTR acc = 0;
    int nDigit;

    while((nDigit = toupper(*szText++)) != 0)
    {
        // If the character is not an alphanumeric, break
        if(!isxdigit(nDigit))
            break;

        // Convert to digit
        nDigit -= _T('0');
        if(nDigit > 9)
            nDigit -= (_T('A') - _T('9') - 1);

        // Move the value to the next rank and add the digit
        acc *= 0x10;
        acc += nDigit;
    }
    return acc;
}

void Hex2TextPtr(DWORD_PTR & dwpValue, TCHAR * szBuffer)
{
    _stprintf(szBuffer, _T("%p"), dwpValue);
}

void Hex2DlgTextPtr(HWND hDlg, UINT nIDCtrl, DWORD_PTR dwpValue)
{
    TCHAR szText[128];

    Hex2TextPtr(dwpValue, szText);
    SetDlgItemText(hDlg, nIDCtrl, szText);
}

//-----------------------------------------------------------------------------
// 64-bit values support

LARGE_INTEGER DlgText2Hex64(HWND hDlg, UINT nIDCtrl)
{
    TCHAR szText[128];

    GetDlgItemText(hDlg, nIDCtrl, szText, _tsize(szText));
    return Text2Hex64(szText);
}

// Converts the string to long. this function was written because
// the builtin strtol does not work correctly (try to convert 0xAABBCCDD !!!)
LARGE_INTEGER Text2Hex64(const TCHAR * szText)
{
    LARGE_INTEGER acc = {0};
    int nDigit;

    while((nDigit = toupper(*szText++)) != 0)
    {
        // If the character is not an alphanumeric, break
        if(!isxdigit(nDigit))
            break;

        // Convert to digit
        nDigit -= _T('0');
        if(nDigit > 9)
            nDigit -= (_T('A') - _T('9') - 1);

        // Move the value to the next rank and add the digit
        acc.QuadPart *= 0x10;
        acc.QuadPart += nDigit;
    }
    return acc;
}

void Hex2Text64(LARGE_INTEGER & liValue, TCHAR * szBuffer)
{
    _stprintf(szBuffer, _T("%I64lX"), liValue.QuadPart);
}

void Hex2DlgText64(HWND hDlg, UINT nIDCtrl, LARGE_INTEGER & liValue)
{
    TCHAR szText[128];

    Hex2Text64(liValue, szText);
    SetDlgItemText(hDlg, nIDCtrl, szText);
}

//-----------------------------------------------------------------------------
// Other

int SetLastErrorText(HWND hDlg, UINT nIDCtrl, int nError)
{
    TCHAR szText[256] = _T("");
    TCHAR szError[200] = _T("");
    DWORD dwLength = 0;

    // Get the text from error message
    dwLength = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, nError, 0, szError, _tsize(szError), NULL) - 1;
        
    // Remove EOLs
    if(dwLength > 0 && (szError[dwLength] == 0x0D || szError[dwLength] == 0x0A))
        szError[dwLength--] = 0;
    if(dwLength > 0 && (szError[dwLength] == 0x0D || szError[dwLength] == 0x0A))
        szError[dwLength--] = 0;

    // Format the result string
    _stprintf(szText, _T("(0x%08lX) %s"), nError, szError);
    SetDlgItemText(hDlg, nIDCtrl, szText);
    return ERROR_SUCCESS;
}

// Calculates the necessary length of PFILE_FULL_EA_INFORMATION structure
ULONG GetEaEntrySize(PFILE_FULL_EA_INFORMATION EaInfo)
{
    ULONG EntrySize = FIELD_OFFSET(FILE_FULL_EA_INFORMATION, EaName[0]);

    //
    // The length of the item must be calculated very exactly.
    // No additional bytes (except for default alignment of 
    // FILE_FULL_EA_INFORMATION structure) is allowed.
    //

    EntrySize += EaInfo->EaNameLength + 1;      // Add the name length plus the ending zero character
    EntrySize += EaInfo->EaValueLength;         // Add the data length
    EntrySize = ALIGN_INT32(EntrySize);          // Align to 4-byte boundary

    return EntrySize;
}

HTREEITEM InsertTreeItem(HWND hTreeView, HTREEITEM hParentItem, LPCTSTR szText, PVOID pParam)
{
    TVINSERTSTRUCT tvis;

    tvis.hParent      = hParentItem;
    tvis.hInsertAfter = TVI_LAST;
    tvis.item.mask    = TVIF_TEXT | TVIF_PARAM;
    tvis.item.pszText = (LPTSTR)szText;
    tvis.item.lParam  = (LPARAM)pParam;
    return TreeView_InsertItem(hTreeView, &tvis);
}

//-----------------------------------------------------------------------------
// Dynamic loaded APIs

CREATETRANSACTION        pfnCreateTransaction     = NULL;
COMMITTRANSACTION        pfnCommitTransaction     = NULL;
ROLLBACKTRANSACTION      pfnRollbackTransaction   = NULL;
RTLGETCURRENTTRANSACTION pfnRtlGetCurrentTransaction = NULL;
RTLSETCURRENTTRANSACTION pfnRtlSetCurrentTransaction = NULL;
CREATEFILETRANSACTED     pfnCreateFileTransacted  = NULL;

static HINSTANCE hNtdll = NULL;
static HINSTANCE hKernel32 = NULL;
static HINSTANCE hKtmw32 = NULL;

void ResolveDynamicLoadedAPIs()
{
    // Get imports from Ntdll.dll
    if(hNtdll == NULL)
    {
        hNtdll = LoadLibrary(_T("Ntdll.dll"));
        if(hNtdll != NULL)
        {
            pfnRtlGetCurrentTransaction = (RTLGETCURRENTTRANSACTION)
                                          GetProcAddress(hNtdll, "RtlGetCurrentTransaction");
            pfnRtlSetCurrentTransaction = (RTLSETCURRENTTRANSACTION)
                                          GetProcAddress(hNtdll, "RtlSetCurrentTransaction");
        }
    }

    // Get imports from Kernel32.dll
    if(hKernel32 == NULL)
    {
        hKernel32 = LoadLibrary(_T("Kernel32.dll"));
        if(hKernel32 != NULL)
        {
#ifdef _UNICODE
            pfnCreateFileTransacted = (CREATEFILETRANSACTED)GetProcAddress(hKernel32, "CreateFileTransactedW");
#else
            pfnCreateFileTransacted = (CREATEFILETRANSACTED)GetProcAddress(hKernel32, "CreateFileTransactedA");
#endif
        }
    }

    // Get imports from Ktmw32.dll
    if(hKtmw32 == NULL)
    {
        hKtmw32 = LoadLibrary(_T("Ktmw32.dll"));
        if(hKtmw32 != NULL)
        {
            pfnCreateTransaction =   (CREATETRANSACTION)GetProcAddress(hKtmw32, "CreateTransaction");
            pfnCommitTransaction =   (COMMITTRANSACTION)GetProcAddress(hKtmw32, "CommitTransaction");
            pfnRollbackTransaction = (ROLLBACKTRANSACTION)GetProcAddress(hKtmw32, "RollbackTransaction");
        }
    }
}

void UnloadDynamicLoadedAPIs()
{
    if(hKtmw32 != NULL)
    {
        pfnCreateTransaction   = NULL;
        pfnCommitTransaction   = NULL;
        pfnRollbackTransaction = NULL;

        FreeLibrary(hKtmw32);
        hKtmw32 = NULL;
    }

    if(hKernel32 != NULL)
    {
        pfnCreateFileTransacted = NULL;

        FreeLibrary(hKernel32);
        hKernel32 = NULL;
    }

    if(hNtdll != NULL)
    {
        pfnRtlGetCurrentTransaction = NULL;
        pfnRtlSetCurrentTransaction = NULL;

        FreeLibrary(hNtdll);
        hNtdll = NULL;
    }
}