unsigned __int32 ulMountedDrives; /* Bitfield of all mounted drive letters */

wchar_t wszVolume[26][TC_MAX_PATH]; /* Volume names of mounted volumes */

wchar_t wszLabel[26][33]; /* Labels of mounted volumes */

unsigned __int64 diskLength[26];

int ea[26];

int volumeType[26]; /* Volume type (e.g. PROP_VOL_TYPE_OUTER, PROP_VOL_TYPE_OUTER_VOL_WRITE_PREVENTED, etc.) */

int volumePim;

wchar_t wszLabel[33];

BOOL bDriverSetLabel;

} VOLUME_PROPERTIES_STRUCT;

typedef struct

BOOL DetectFilesystem;

BOOL FilesystemDetected;

BOOL bMatchVolumeID;

BOOL VolumeIDMatched;

} OPEN_TEST_STRUCT;

#define MAX_HOST_DRIVE_NUMBER 64

#define MAX_HOST_PARTITION_NUMBER 32

typedef enum

{

// IMPORTANT: If you add a new item here, update IsOSVersionAtLeast().

}

}

{

DWORD dwResult;

BOOL bResult;

driver->DetectFilesystem = detectFilesystem;

driver->bMatchVolumeID = matchVolumeID;

if (matchVolumeID && pbVolumeID)

bResult = DeviceIoControl (hDriver, TC_IOCTL_OPEN_TEST,

driver, sizeof (OPEN_TEST_STRUCT),

{

driver->TCBootLoaderDetected = FALSE;

driver->FilesystemDetected = FALSE;

return TRUE;

}

else

/************************************************************************/

{

if (useVolumeID)

{

{

MOUNT_STRUCT* pmount;

BOOL useVolumeID;

BOOL* pbResult;

DWORD* pdwResult;

DWORD dwLastError;

wchar_t root[MAX_PATH];

int favoriteMountOnArrivalRetryCount = 0;

BOOL useVolumeID = FALSE;

#ifdef TCMOUNT

if (mountOptions->PartitionInInactiveSysEncScope)

if ((path.length () >= 3) && (_wcsnicmp (path.c_str(), L"ID:", 3) == 0))

{

std::vector<byte> arr;

&& HexWideStringToArray (path.c_str() + 3, arr)

)

{

useVolumeID = TRUE;

bDevice = TRUE;

}

else

{

MountThreadParam mountThreadParam;

mountThreadParam.pmount = &mount;

mountThreadParam.useVolumeID = useVolumeID;

mountThreadParam.pbResult = &bResult;

mountThreadParam.pdwResult = &dwResult;

mountThreadParam.dwLastError = ERROR_SUCCESS;

return !DeviceIoControl (hDriver, TC_IOCTL_GET_PASSWORD_CACHE_STATUS, 0, 0, 0, 0, &dw, 0);

}

{

MOUNT_LIST_STRUCT mlist;

DWORD dwResult;

sizeof (mlist), &mlist, sizeof (mlist), &dwResult,

NULL);

{

/* Volume ID specified. Use it for matching mounted volumes. */

std::vector<byte> arr;

{

}

}

else

{

wchar_t volume[TC_MAX_PATH*2+16];

StringCbCopyW (volume, sizeof(volume), volname);

if (!resolvedPath.empty())

StringCbCopyW (volume, sizeof (volume), resolvedPath.c_str());

for (i=0 ; i<26; i++)

if (0 == _wcsicmp ((wchar_t *) mlist.wszVolume[i], volume))

return TRUE;

return devices;

}

{

for (int devNumber = 0; devNumber < MAX_HOST_DRIVE_NUMBER; devNumber++)

{

for (int partNumber = 0; partNumber < MAX_HOST_PARTITION_NUMBER; partNumber++)

UpperCaseCopy (upperCasePath, sizeof(upperCasePath), volumePath);

if (wcsstr (upperCasePath, L"\\DEVICE\\") == upperCasePath)

return OpenDevice (volumePath, &openTest, FALSE, FALSE, NULL);

return FALSE;

}

IDPM_ADD_TO_FAVORITES,

IDPM_ADD_TO_SYSTEM_FAVORITES,

IDM_SHOW_HIDE,

};

enum

void InitApp ( HINSTANCE hInstance, wchar_t *lpszCommandLine );

void FinalizeApp (void);

void InitHelpFileName (void);

void NotifyDriverOfPortableMode (void);

int GetAvailableFixedDisks ( HWND hComboBox , char *lpszRootPath );

int GetAvailableRemovables ( HWND hComboBox , char *lpszRootPath );

BOOL UnmountVolume (HWND hwndDlg , int nDosDriveNo, BOOL forceUnmount);

BOOL UnmountVolumeAfterFormatExCall (HWND hwndDlg, int nDosDriveNo);

BOOL IsPasswordCacheEmpty (void);

BOOL IsMountedVolume (const wchar_t *volname);

int GetMountedVolumeDriveNo (wchar_t *volname);

BOOL IsAdmin (void);

void ProcessEntropyEstimate (HWND hProgress, DWORD* pdwInitialValue, DWORD dwCounter, DWORD dwMaxLevel, DWORD* pdwEntropy);

void AllowMessageInUIPI (UINT msg);

BOOL IsRepeatedByteArray (byte value, const byte* buffer, size_t bufferSize);

#ifdef __cplusplus

}

std::wstring IntToWideString (int val);

std::wstring ArrayToHexWideString (const unsigned char* pbData, int cbData);

bool HexWideStringToArray (const wchar_t* hexStr, std::vector<byte>& arr);

void RegisterDriverInf (bool registerFilter, const std::string& filter, const std::string& filterReg, HWND ParentWindow, HKEY regKey);

std::wstring GetTempPathString ();

inline std::wstring AppendSrcPos (const wchar_t* msg, const char* srcPos)

<string lang="en" key="INIT_DLL">Error: Failed to load a system library.</string>

<string lang="en" key="ERR_EXFAT_INVALID_VOLUME_SIZE">The volume file size specified in the command line is incompatible with selected exFAT filesystem.</string>

<control lang="en" key="IDT_ENTROPY_BAR">Randomness Collected From Mouse Movements</control>

<control lang="en" key="IDC_FAVORITE_USE_VOLUME_ID">Use Volume ID to mount favorite</control>

<string lang="en" key="VOLUME_ID_INVALID">The Volume ID value is invalid</string>

</localization>

<!-- XML Schema -->

<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">