page05ntcreate.cpp

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

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

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

#define FILE_ID_SIZE 16

//-----------------------------------------------------------------------------
// Flags

static TFlagInfo DesiredAccessValues[] =
{
    {FILE_READ_DATA,         _T("FILE_READ_DATA/FILE_LIST_DIRECTORY"),     TRUE},
    {FILE_WRITE_DATA,        _T("FILE_WRITE_DATA/FILE_ADD_FILE"),          TRUE},
    {FILE_APPEND_DATA,       _T("FILE_APPEND_DATA/FILE_ADD_SUBDIRECTORY"), TRUE},
    {FILE_READ_EA,           _T("FILE_READ_EA"),                           TRUE},
    {FILE_WRITE_EA,          _T("FILE_WRITE_EA"),                          TRUE},
    {FILE_EXECUTE,           _T("FILE_EXECUTE/FILE_TRAVERSE"),             TRUE},
    {FILE_DELETE_CHILD,      _T("FILE_DELETE_CHILD"),                      TRUE},
    {FILE_READ_ATTRIBUTES,   _T("FILE_READ_ATTRIBUTES"),                   TRUE},
    {FILE_WRITE_ATTRIBUTES,  _T("FILE_WRITE_ATTRIBUTES"),                  TRUE},
    {DELETE,                 _T("DELETE"),                                 TRUE},
    {READ_CONTROL,           _T("READ_CONTROL"),                           TRUE},
    {WRITE_DAC,              _T("WRITE_DAC"),                              TRUE},
    {WRITE_OWNER,            _T("WRITE_OWNER"),                            TRUE},
    {SYNCHRONIZE,            _T("SYNCHRONIZE"),                            TRUE},
    {GENERIC_READ,           _T("GENERIC_READ"),                           TRUE},
    {GENERIC_WRITE,          _T("GENERIC_WRITE"),                          TRUE},
    {GENERIC_EXECUTE,        _T("GENERIC_EXECUTE"),                        TRUE},
    {GENERIC_ALL,            _T("GENERIC_ALL"),                            TRUE},
    {0, 0, 0}
};

// Also necessary in Page04FileOps.cpp
TFlagInfo FileAttributesValues[] =
{
    {FILE_ATTRIBUTE_READONLY,            _T("FILE_ATTRIBUTE_READONLY"),            TRUE},
    {FILE_ATTRIBUTE_HIDDEN,              _T("FILE_ATTRIBUTE_HIDDEN"),              TRUE},
    {FILE_ATTRIBUTE_SYSTEM,              _T("FILE_ATTRIBUTE_SYSTEM"),              TRUE},
    {OLD_DOS_VOLID,                      _T("OLD_DOS_VOLID"),                      FALSE},
    {FILE_ATTRIBUTE_DIRECTORY,           _T("FILE_ATTRIBUTE_DIRECTORY"),           TRUE},
    {FILE_ATTRIBUTE_ARCHIVE,             _T("FILE_ATTRIBUTE_ARCHIVE"),             TRUE},
    {FILE_ATTRIBUTE_DEVICE,              _T("FILE_ATTRIBUTE_DEVICE"),              TRUE},
    {FILE_ATTRIBUTE_NORMAL,              _T("FILE_ATTRIBUTE_NORMAL"),              TRUE},
    {FILE_ATTRIBUTE_TEMPORARY,           _T("FILE_ATTRIBUTE_TEMPORARY"),           TRUE},
    {FILE_ATTRIBUTE_SPARSE_FILE,         _T("FILE_ATTRIBUTE_SPARSE_FILE"),         TRUE},
    {FILE_ATTRIBUTE_REPARSE_POINT,       _T("FILE_ATTRIBUTE_REPARSE_POINT"),       TRUE},
    {FILE_ATTRIBUTE_COMPRESSED,          _T("FILE_ATTRIBUTE_COMPRESSED"),          TRUE},
    {FILE_ATTRIBUTE_OFFLINE,             _T("FILE_ATTRIBUTE_OFFLINE"),             TRUE},
    {FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, _T("FILE_ATTRIBUTE_NOT_CONTENT_INDEXED"), TRUE},
    {FILE_ATTRIBUTE_ENCRYPTED,           _T("FILE_ATTRIBUTE_ENCRYPTED"),           TRUE},
    {0, 0, 0}
};

static TFlagInfo ShareAccessValues[] =
{
    {FILE_SHARE_READ,   _T("FILE_SHARE_READ"),   TRUE},
    {FILE_SHARE_WRITE,  _T("FILE_SHARE_WRITE"),  TRUE},
    {FILE_SHARE_DELETE, _T("FILE_SHARE_DELETE"), TRUE},
    {0, 0, 0}
};

static TFlagInfo CreateOptionsValues[] =
{
    {FILE_DIRECTORY_FILE,            _T("FILE_DIRECTORY_FILE"),            TRUE},
    {FILE_WRITE_THROUGH,             _T("FILE_WRITE_THROUGH"),             TRUE},
    {FILE_SEQUENTIAL_ONLY,           _T("FILE_SEQUENTIAL_ONLY"),           TRUE},
    {FILE_NO_INTERMEDIATE_BUFFERING, _T("FILE_NO_INTERMEDIATE_BUFFERING"), TRUE},
    {FILE_SYNCHRONOUS_IO_ALERT,      _T("FILE_SYNCHRONOUS_IO_ALERT"),      TRUE},
    {FILE_SYNCHRONOUS_IO_NONALERT,   _T("FILE_SYNCHRONOUS_IO_NONALERT"),   TRUE},
    {FILE_NON_DIRECTORY_FILE,        _T("FILE_NON_DIRECTORY_FILE"),        TRUE},
    {FILE_CREATE_TREE_CONNECTION,    _T("FILE_CREATE_TREE_CONNECTION"),    TRUE},
    {FILE_COMPLETE_IF_OPLOCKED,      _T("FILE_COMPLETE_IF_OPLOCKED"),      TRUE},
    {FILE_NO_EA_KNOWLEDGE,           _T("FILE_NO_EA_KNOWLEDGE"),           TRUE},
    {FILE_OPEN_FOR_RECOVERY,         _T("FILE_OPEN_FOR_RECOVERY"),         TRUE},
    {FILE_RANDOM_ACCESS,             _T("FILE_RANDOM_ACCESS"),             TRUE},
    {FILE_DELETE_ON_CLOSE,           _T("FILE_DELETE_ON_CLOSE"),           TRUE},
    {FILE_OPEN_BY_FILE_ID,           _T("FILE_OPEN_BY_FILE_ID"),           TRUE},
    {FILE_OPEN_FOR_BACKUP_INTENT,    _T("FILE_OPEN_FOR_BACKUP_INTENT"),    TRUE},
    {FILE_NO_COMPRESSION,            _T("FILE_NO_COMPRESSION"),            TRUE},
    {FILE_RESERVE_OPFILTER,          _T("FILE_RESERVE_OPFILTER"),          TRUE},
    {FILE_OPEN_REPARSE_POINT,        _T("FILE_OPEN_REPARSE_POINT"),        TRUE},
    {FILE_OPEN_NO_RECALL,            _T("FILE_OPEN_NO_RECALL"),            TRUE},
    {FILE_OPEN_FOR_FREE_SPACE_QUERY, _T("FILE_OPEN_FOR_FREE_SPACE_QUERY"), TRUE},
    {0, 0, 0}
};

static TFlagInfo ObjAttrFlagsValues[] =
{
    {OBJ_INHERIT,                    _T("OBJ_INHERIT"),                    TRUE},
    {OBJ_PERMANENT,                  _T("OBJ_PERMANENT"),                  TRUE},
    {OBJ_EXCLUSIVE,                  _T("OBJ_EXCLUSIVE"),                  TRUE},
    {OBJ_CASE_INSENSITIVE,           _T("OBJ_CASE_INSENSITIVE"),           TRUE},    
    {OBJ_OPENIF,                     _T("OBJ_OPENIF"),                     TRUE},
    {OBJ_OPENLINK,                   _T("OBJ_OPENLINK"),                   TRUE},
    {OBJ_KERNEL_HANDLE,              _T("OBJ_KERNEL_HANDLE"),              TRUE},
    {OBJ_FORCE_ACCESS_CHECK,         _T("OBJ_FORCE_ACCESS_CHECK"),         TRUE},
    {0, 0, 0}                        
};

//-----------------------------------------------------------------------------
// Local functions

static void SetNtOperationResult(HWND hDlg, NTSTATUS Status, PIO_STATUS_BLOCK pIoStatus)
{
    TPropSheetData * pData = (TPropSheetData *)GetWindowLongPtr(hDlg, DWLP_USER);
    BOOL bEnable = TRUE;

    TCHAR * szIoStatus[] = 
    {
        _T("FILE_SUPERSEDED"),
        _T("FILE_OPENED"),
        _T("FILE_CREATED"),
        _T("FILE_OVERWRITTEN"),
        _T("FILE_EXISTS"),
        _T("FILE_DOES_NOT_EXIST")
    };

    SetDlgItemText(hDlg, IDC_RESULT_STATUS, NtStatus2Text(Status));
    Hex2DlgTextPtr(hDlg, IDC_FILE_HANDLE, (DWORD_PTR)pData->hFile);

    // Set the IO status
    if(Status == STATUS_SUCCESS && pIoStatus != NULL && pIoStatus->Information <= FILE_DOES_NOT_EXIST)
        SetDlgItemText(hDlg, IDC_IOSTATUS_RESULT, szIoStatus[pIoStatus->Information]);
    else
        SetDlgItemText(hDlg, IDC_IOSTATUS_RESULT, _T(""));

    // Enable NtClose only if the handle has been retrieved using NtCreateFile
    if(IsHandleInvalid(pData->hFile))
        bEnable = FALSE;
    EnableWindow(GetDlgItem(hDlg, IDC_CLOSEHINT), bEnable);
    EnableWindow(GetDlgItem(hDlg, IDC_NTCLOSE), bEnable);
}

static int ConvertStringToFileID(HWND hDlg, UINT nIDCtrl, UNICODE_STRING & FileName)
{
    LARGE_INTEGER FileId = {0};

    // Convert the value to 64bit integer and copy to the UNICODE_STRING
    FileId = DlgText2Hex64(hDlg, nIDCtrl);
    memcpy((PCHAR)FileName.Buffer, &FileId, sizeof(FileId));
    FileName.Length = sizeof(FileId);
    return ERROR_SUCCESS;
}

static int SaveDialog(HWND hDlg)
{
    TPropSheetData * pData = (TPropSheetData *)GetWindowLongPtr(hDlg, DWLP_USER);
    HWND hCombo = GetDlgItem(hDlg, IDC_CREATE_DISPOSITION);

    GetDlgItemText(hDlg, IDC_RELATIVE_FILE, pData->szDirName, _tsize(pData->szDirName));
    GetDlgItemText(hDlg, IDC_FILE_NAME, pData->szFileName1, _tsize(pData->szFileName1));
    pData->dwDesiredAccess     = DlgText2Hex32(hDlg, IDC_DESIRED_ACCESS);
    pData->dwFileAttributes    = DlgText2Hex32(hDlg, IDC_FILE_ATTRIBUTES);
    pData->dwShareAccess       = DlgText2Hex32(hDlg, IDC_SHARE_ACCESS);
    pData->dwCreateOptions     = DlgText2Hex32(hDlg, IDC_CREATE_OPTIONS);
    pData->dwObjAttrFlags      = DlgText2Hex32(hDlg, IDC_OBJ_ATTR_FLAGS);
    pData->liAllocationSize    = DlgText2Hex64(hDlg, IDC_ALLOCATION_SIZE);
    pData->dwCreateDisposition = ComboBox_GetCurSel(hCombo);
    pData->bUseTransaction     = (IsDlgButtonChecked(hDlg, IDC_TRANSACTED) == BST_CHECKED);

    return ERROR_SUCCESS;
}
                                                             
//-----------------------------------------------------------------------------
// Message handlers

static int ConvertToNtName(HWND hDlg, UINT nIDEdit)
{
    UNICODE_STRING NtName = {0};
    NTSTATUS Status = STATUS_SUCCESS;
    HWND hEdit = GetDlgItem(hDlg, nIDEdit);
    TCHAR * szFileName = NULL;
    int nLength = GetWindowTextLength(hEdit) + 1;

    __try
    {
        if(nLength == 1)
            return STATUS_SUCCESS;

        // Allocate buffer
        szFileName = new TCHAR[nLength];
        if(szFileName == NULL)
            return ERROR_NOT_ENOUGH_MEMORY;

        // Get the window text
        // If it already appears to be an NT name, do nothing
        GetWindowText(hEdit, szFileName, nLength);
        if(szFileName[0] == 0 || szFileName[0] == _T('\\') || szFileName[1] != _T(':'))
            return ERROR_SUCCESS;

        Status = RtlDosPathNameToNtPathName_U(szFileName,
                                             &NtName,
                                              NULL,
                                              NULL);

        //
        // Maximum names that may be handled by RtlDosPathNameToNtPathName_U
        // is about 0x200 charascters.
        //

        if(!NT_SUCCESS(Status) || NtName.Length == 0)
        {
            if(isalpha(szFileName[0]) && szFileName[1] == _T(':') && szFileName[2] == _T('\\'))
            {
                NtName.MaximumLength = (USHORT)(nLength + 5);
                NtName.Length = (USHORT)(nLength + 4);
                NtName.Buffer = (PWSTR)HeapAlloc(g_hHeap, HEAP_ZERO_MEMORY, NtName.MaximumLength);
                _tcscpy(NtName.Buffer, _T("\\??\\"));
                _tcscat(NtName.Buffer, szFileName);
            }
        }

        // Set the NT name to the edit box
        if(NtName.Length != 0)
            SetWindowText(hEdit, NtName.Buffer);
    }
    __finally
    {
        if(NtName.Buffer != NULL)
            HeapFree(g_hHeap, 0, NtName.Buffer);
        if(szFileName != NULL)
            delete [] szFileName;
    }

    return Status;
}

static int OnBrowseDirClick(HWND hDlg)
{
    BrowseForDirectory(hDlg, IDC_RELATIVE_FILE, IDS_SELECT_DIRECTORY);
    ConvertToNtName(hDlg, IDC_RELATIVE_FILE);
    return TRUE;
}

static int OnBrowseFileClick(HWND hDlg)
{
    if(BrowseForFile(hDlg, 0, MAKEINTRESOURCE(IDC_FILE_NAME), IDS_SELECT_FILE, IDS_FILTER_ALL))
    {
        SetDlgItemText(hDlg, IDC_RELATIVE_FILE, _T(""));
        ConvertToNtName(hDlg, IDC_FILE_NAME);
    }
    return TRUE;
}

static int OnDesiredAccessClick(HWND hDlg)
{
    TFlagDialogData DesiredAccessData;

    DesiredAccessData.hParent  = hDlg;
    DesiredAccessData.nIDTitle = IDS_DESIRED_ACCESS;
    DesiredAccessData.dwFlags  = DlgText2Hex32(hDlg, IDC_DESIRED_ACCESS);
    DesiredAccessData.nFlags   = sizeof(DesiredAccessValues) / sizeof(TFlagInfo);
    DesiredAccessData.Flags    = DesiredAccessValues;

    FlagsDialog(&DesiredAccessData);
    Hex2DlgText32(hDlg, IDC_DESIRED_ACCESS, DesiredAccessData.dwFlags);
    return TRUE;
}

static int OnFileAttributesClick(HWND hDlg)
{
    TFlagDialogData FileAttributesData;

    FileAttributesData.hParent  = hDlg;
    FileAttributesData.nIDTitle = IDS_FILE_ATTRIBUTES;
    FileAttributesData.dwFlags  = DlgText2Hex32(hDlg, IDC_FILE_ATTRIBUTES);
    FileAttributesData.nFlags   = sizeof(FileAttributesValues) / sizeof(TFlagInfo);
    FileAttributesData.Flags    = FileAttributesValues;

    FlagsDialog(&FileAttributesData);
    Hex2DlgText32(hDlg, IDC_FILE_ATTRIBUTES, FileAttributesData.dwFlags);
    return TRUE;
}

static int OnShareAccessClick(HWND hDlg)
{
    TFlagDialogData ShareAccessData;

    ShareAccessData.hParent  = hDlg;
    ShareAccessData.nIDTitle = IDS_SHARE_ACCESS;
    ShareAccessData.dwFlags  = DlgText2Hex32(hDlg, IDC_SHARE_ACCESS);
    ShareAccessData.nFlags   = sizeof(ShareAccessValues) / sizeof(TFlagInfo);
    ShareAccessData.Flags    = ShareAccessValues;

    FlagsDialog(&ShareAccessData);
    Hex2DlgText32(hDlg, IDC_SHARE_ACCESS, ShareAccessData.dwFlags);
    return TRUE;
}

static int OnCreateOptionsClick(HWND hDlg)
{
    TFlagDialogData CreateOptionsData;

    CreateOptionsData.hParent  = hDlg;