void AbortProcessSilent ( void );

void *err_malloc ( size_t size );

char *err_strdup ( char *lpszText );

DWORD handleWin32Error ( HWND hwndDlg, const char* srcPos );

BOOL IsDiskReadError (DWORD error);

BOOL IsDiskWriteError (DWORD error);

BOOL IsDiskError (DWORD error);

BOOL translateWin32Error ( wchar_t *lpszMsgBuf , int nWSizeOfBuf );

BOOL CALLBACK AboutDlgProc ( HWND hwndDlg , UINT msg , WPARAM wParam , LPARAM lParam );

static BOOL CALLBACK StaticModelessWaitDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);

void DisplayStaticModelessWaitDlg (HWND parent);

void CloseStaticModelessWaitDlg (void);

BOOL IsButtonChecked ( HWND hButton );

void CheckButton ( HWND hButton );

void LeftPadString (wchar_t *szTmp, int len, int targetLen, wchar_t filler);

void InitDialog ( HWND hwndDlg );

void ProcessPaintMessages (HWND hwnd, int maxMessagesToProcess);

HDC CreateMemBitmap ( HINSTANCE hInstance , HWND hwnd , wchar_t *resource );

HBITMAP RenderBitmap ( wchar_t *resource , HWND hwndDest , int x , int y , int nWidth , int nHeight , BOOL bDirectRender , BOOL bKeepAspectRatio);

LRESULT CALLBACK RedTick ( HWND hwnd , UINT uMsg , WPARAM wParam , LPARAM lParam );

BOOL RegisterRedTick ( HINSTANCE hInstance );

BOOL UnregisterRedTick ( HINSTANCE hInstance );

LRESULT CALLBACK SplashDlgProc ( HWND hwnd , UINT uMsg , WPARAM wParam , LPARAM lParam );

void WaitCursor ( void );

void NormalCursor ( void );

void ArrowWaitCursor ( void );

void HandCursor ();

void AddComboPair (HWND hComboBox, const wchar_t *lpszItem, int value);

void SelectAlgo ( HWND hComboBox , int *nCipher );

void PopulateWipeModeCombo (HWND hComboBox, BOOL bNA, BOOL bInPlaceEncryption, BOOL bHeaderWipe);

wchar_t *GetWipeModeName (WipeAlgorithmId modeId);

wchar_t *GetPathType (const wchar_t *path, BOOL bUpperCase, BOOL *bIsPartition);

LRESULT CALLBACK CustomDlgProc ( HWND hwnd , UINT uMsg , WPARAM wParam , LPARAM lParam );

BOOL TCCreateMutex (volatile HANDLE *hMutex, wchar_t *name);

void TCCloseMutex (volatile HANDLE *hMutex);

BOOL MutexExistsOnSystem (wchar_t *name);

BOOL CreateSysEncMutex (void);

BOOL InstanceHasSysEncMutex (void);

void CloseSysEncMutex (void);

BOOL CreateNonSysInplaceEncMutex (void);

BOOL InstanceHasNonSysInplaceEncMutex (void);

void CloseNonSysInplaceEncMutex (void);

BOOL NonSysInplaceEncInProgressElsewhere (void);

BOOL CreateDriverSetupMutex (void);

void CloseDriverSetupMutex (void);

BOOL CreateAppSetupMutex (void);

BOOL InstanceHasAppSetupMutex (void);

void CloseAppSetupMutex (void);

BOOL IsTrueCryptInstallerRunning (void);

uint32 ReadDriverConfigurationFlags ();

uint32 ReadServiceConfigurationFlags ();

uint32 ReadEncryptionThreadPoolFreeCpuCountLimit ();

BOOL LoadSysEncSettings ();

int LoadNonSysInPlaceEncSettings (WipeAlgorithmId *wipeAlgorithm);

void RemoveNonSysInPlaceEncNotifications (void);

void SavePostInstallTasksSettings (int command);

void DoPostInstallTasks (HWND hwndDlg);

void InitOSVersionInfo ();

void InitApp ( HINSTANCE hInstance, wchar_t *lpszCommandLine );

void InitHelpFileName (void);

BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectFilesystem, BOOL computeVolumeID);

void NotifyDriverOfPortableMode (void);

int GetAvailableFixedDisks ( HWND hComboBox , char *lpszRootPath );

int GetAvailableRemovables ( HWND hComboBox , char *lpszRootPath );

int IsSystemDevicePath (const wchar_t *path, HWND hwndDlg, BOOL bReliableRequired);

int IsNonSysPartitionOnSysDrive (const wchar_t *path);

BOOL CALLBACK RawDevicesDlgProc ( HWND hwndDlg , UINT msg , WPARAM wParam , LPARAM lParam );

BOOL CALLBACK TextEditDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);

INT_PTR TextInfoDialogBox (int nID);

BOOL CALLBACK TextInfoDialogBoxDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);

char * GetLegalNotices ();

BOOL CALLBACK BenchmarkDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);

void UserEnrichRandomPool (HWND hwndDlg);

BOOL CALLBACK KeyfileGeneratorDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);

BOOL CALLBACK MultiChoiceDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

int DriverAttach ( void );

BOOL CALLBACK CipherTestDialogProc ( HWND hwndDlg , UINT uMsg , WPARAM wParam , LPARAM lParam );

void ResetCipherTest ( HWND hwndDlg , int idTestCipher );

void ResetCurrentDirectory ();

void handleError ( HWND hwndDlg , int code, const char* srcPos );

BOOL CheckFileStreamWriteErrors (HWND hwndDlg, FILE *file, const wchar_t *fileName);

void LocalizeDialog ( HWND hwnd, char *stringId );

void OpenVolumeExplorerWindow (int driveNo);

static BOOL CALLBACK CloseVolumeExplorerWindowsEnum( HWND hwnd, LPARAM driveNo);

BOOL CloseVolumeExplorerWindows (HWND hwnd, int driveNo);

BOOL UpdateDriveCustomLabel (int driveNo, wchar_t* effectiveLabel, BOOL bSetValue);

BOOL CheckCapsLock (HWND hwnd, BOOL quiet);

BOOL CheckFileExtension (wchar_t *fileName);

void CorrectFileName (wchar_t* fileName);

void CorrectURL (wchar_t* fileName);

void IncreaseWrongPwdRetryCount (int count);

void ResetWrongPwdRetryCount (void);

BOOL WrongPwdRetryCountOverLimit (void);

DWORD GetUsedLogicalDrives (void);

int GetFirstAvailableDrive ();

int GetLastAvailableDrive ();

BOOL IsDriveAvailable (int driveNo);

BOOL IsDeviceMounted (wchar_t *deviceName);

int DriverUnmountVolume (HWND hwndDlg, int nDosDriveNo, BOOL forced);

void BroadcastDeviceChange (WPARAM message, int nDosDriveNo, DWORD driveMap);

int MountVolume (HWND hwndDlg, int driveNo, wchar_t *volumePath, Password *password, int pkcs5, int pim, BOOL cachePassword, BOOL cachePim, BOOL sharedAccess, const MountOptions* const mountOptions, BOOL quiet, BOOL bReportWrongPassword);

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

BOOL UnmountVolumeAfterFormatExCall (HWND hwndDlg, int nDosDriveNo);

BOOL IsPasswordCacheEmpty (void);

BOOL IsMountedVolumeID (BYTE volumeID[VOLUME_ID_SIZE]);

BOOL IsMountedVolume (const wchar_t *volname);

int GetMountedVolumeDriveNo (wchar_t *volname);

BOOL IsAdmin (void);

BOOL IsBuiltInAdmin ();

BOOL ConfigWriteBegin ();

BOOL ConfigWriteEnd (HWND hwnd);

BOOL ConfigWriteString (char *configKey, char *configValue);

BOOL ConfigWriteStringW (char *configKey, wchar_t *configValue);

BOOL ConfigWriteInt (char *configKey, int configValue);

int ConfigReadInt (char *configKey, int defaultValue);

char *ConfigReadString (char *configKey, char *defaultValue, char *str, int maxLen);

void ConfigReadCompareInt(char *configKey, int defaultValue, int* pOutputValue, BOOL bOnlyCheckModified, BOOL* pbModified);

void ConfigReadCompareString (char *configKey, char *defaultValue, char *str, int maxLen, BOOL bOnlyCheckModified, BOOL *pbModified);

void RestoreDefaultKeyFilesParam (void);

BOOL LoadDefaultKeyFilesParam (void);

void Debug (char *format, ...);

void DebugMsgBox (char *format, ...);

BOOL IsOSAtLeast (OSVersionEnum reqMinOS);

BOOL IsOSVersionAtLeast (OSVersionEnum reqMinOS, int reqMinServicePack);

BOOL IsSupportedOS ();

BOOL Is64BitOs ();

BOOL IsARM();

BOOL IsServerOS ();

BOOL IsHiddenOSRunning (void);

BOOL EnableWow64FsRedirection (BOOL enable);

BOOL RestartComputer (BOOL bShutdown);

void Applink (const char *dest);

wchar_t *RelativePath2Absolute (wchar_t *szFileName);

void HandleDriveNotReadyError (HWND hwnd);

BOOL CALLBACK CloseTCWindowsEnum( HWND hwnd, LPARAM lParam);

BOOL CALLBACK FindTCWindowEnum (HWND hwnd, LPARAM lParam);

BYTE *MapResource (wchar_t *resourceType, int resourceId, PDWORD size);

void InconsistencyResolved (char *msg);

void ReportUnexpectedState (const char *techInfo);

void OpenOnlineHelp ();

BOOL GetPartitionInfo (const wchar_t *deviceName, PPARTITION_INFORMATION rpartInfo);

BOOL GetDeviceInfo (const wchar_t *deviceName, DISK_PARTITION_INFO_STRUCT *info);

BOOL GetDriveGeometry (const wchar_t *deviceName, PDISK_GEOMETRY_EX diskGeometry);

BOOL GetPhysicalDriveGeometry (int driveNumber, PDISK_GEOMETRY diskGeometry);

BOOL IsVolumeDeviceHosted (const wchar_t *lpszDiskFile);

int CompensateXDPI (int val);

int CompensateYDPI (int val);

int CompensateDPIFont (int val);

int GetTextGfxWidth (HWND hwndDlgItem, const wchar_t *text, HFONT hFont);

int GetTextGfxHeight (HWND hwndDlgItem, const wchar_t *text, HFONT hFont);

BOOL ToHyperlink (HWND hwndDlg, UINT ctrlId);

BOOL ToCustHyperlink (HWND hwndDlg, UINT ctrlId, HFONT hFont);

void DisableCloseButton (HWND hwndDlg);

void EnableCloseButton (HWND hwndDlg);

void ToBootPwdField (HWND hwndDlg, UINT ctrlId);

void ToNormalPwdField (HWND hwndDlg, UINT ctrlId);

void AccommodateTextField (HWND hwndDlg, UINT ctrlId, BOOL bFirstUpdate, HFONT hFont);

BOOL GetDriveLabel (int driveNo, wchar_t *label, int labelSize);

BOOL GetSysDevicePaths (HWND hwndDlg);

BOOL DoDriverInstall (HWND hwndDlg);

int OpenVolume (OpenVolumeContext *context, const wchar_t *volumePath, Password *password, int pkcs5_prf, int pim, BOOL write, BOOL preserveTimestamps, BOOL useBackupHeader);

void CloseVolume (OpenVolumeContext *context);

int ReEncryptVolumeHeader (HWND hwndDlg, char *buffer, BOOL bBoot, CRYPTO_INFO *cryptoInfo, Password *password, int pim, BOOL wipeMode);

BOOL IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly);

BOOL IsPagingFileWildcardActive ();

BOOL DisablePagingFile ();

BOOL CALLBACK SecurityTokenPasswordDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);

BOOL CALLBACK SecurityTokenKeyfileDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);

BOOL InitSecurityTokenLibrary (HWND hwndDlg);

BOOL FileHasReadOnlyAttribute (const wchar_t *path);

BOOL IsFileOnReadOnlyFilesystem (const wchar_t *path);

void CheckFilesystem (HWND hwndDlg, int driveNo, BOOL fixErrors);

int AskNonSysInPlaceEncryptionResume (HWND hwndDlg, BOOL* pbDecrypt);

BOOL RemoveDeviceWriteProtection (HWND hwndDlg, wchar_t *devicePath);

void EnableElevatedCursorChange (HWND parent);

BOOL DisableFileCompression (HANDLE file);

BOOL VolumePathExists (const wchar_t *volumePath);

BOOL IsWindowsIsoBurnerAvailable ();

BOOL LaunchWindowsIsoBurner (HWND hwnd, const wchar_t *isoPath);

BOOL IsApplicationInstalled (const wchar_t *appName);

int GetPim (HWND hwndDlg, UINT ctrlId, int defaultPim);

void SetPim (HWND hwndDlg, UINT ctrlId, int pim);

BOOL GetPassword (HWND hwndDlg, UINT ctrlID, char* passValue, int bufSize, BOOL bLegacyPassword, BOOL bShowError);

void SetPassword (HWND hwndDlg, UINT ctrlID, char* passValue);

void HandleShowPasswordFieldAction (HWND hwndDlg, UINT checkBoxId, UINT edit1Id, UINT edit2Id);

HKEY OpenDeviceClassRegKey (const GUID *deviceClassGuid);

LSTATUS DeleteRegistryKey (HKEY, LPCTSTR);

HIMAGELIST CreateImageList(int cx, int cy, UINT flags, int cInitial, int cGrow);

int AddBitmapToImageList(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask);

HRESULT VCStrDupW(LPCWSTR psz, LPWSTR *ppwsz);

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

void AllowMessageInUIPI (UINT msg);

BOOL TranslateVolumeID (HWND hwndDlg, wchar_t* pathValue, size_t cchPathValue);

BOOL CopyTextToClipboard (const wchar_t* txtValue);

BOOL LaunchElevatedProcess (HWND hwndDlg, const wchar_t* szModPath, const wchar_t* args);

BOOL GetFreeDriveLetter(WCHAR* pCh);

BOOL SetPrivilege(LPTSTR szPrivilegeName, BOOL bEnable);

BOOL DeleteDirectory (const wchar_t* szDirName);

BOOL IsThreadInSecureDesktop(DWORD dwThreadID);

INT_PTR SecureDesktopDialogBoxParam (HINSTANCE, LPCWSTR, HWND, DLGPROC, LPARAM);

BOOL VerifyModuleSignature (const wchar_t* path);

void GetInstallationPath (HWND hwndDlg, wchar_t* szInstallPath, DWORD cchSize, BOOL* pbInstallPathDetermined);

BOOL GetSetupconfigLocation (wchar_t* path, DWORD cchSize);

BOOL BufferHasPattern (const unsigned char* buffer, size_t bufferLen, const void* pattern, size_t patternLen);

void SafeOpenURL (LPCWSTR szUrl);

BitLockerEncryptionStatus GetBitLockerEncryptionStatus(WCHAR driveLetter);

BOOL IsTestSigningModeEnabled ();

DWORD SendServiceNotification (DWORD dwNotificationCmd);

#ifdef _WIN64

void GetAppRandomSeed (unsigned char* pbRandSeed, size_t cbRandSeed);

#endif

#ifdef __cplusplus

}

#include <vector>

#include <string>

typedef std::vector<unsigned char> ByteArray;

struct HostDevice

{

HostDevice ()

:

Bootable (false),

ContainsSystem (false),

DynamicVolume (false),

Floppy (false),

IsPartition (false),

IsVirtualPartition (false),

HasUnencryptedFilesystem (false),

Removable (false),

Size (0),

SystemNumber((uint32) -1),

HasVolumeIDs (false)

{

ZeroMemory (VolumeIDs, sizeof (VolumeIDs));

}

HostDevice (const HostDevice& device)

:

Bootable (device.Bootable),

memcpy (VolumeIDs, device.VolumeIDs, sizeof (VolumeIDs));

}

return *this;

}

bool Bootable;

bool ContainsSystem;

bool DynamicVolume;

bool Floppy;

bool IsPartition;

bool IsVirtualPartition;

bool HasUnencryptedFilesystem;

std::wstring MountPoint;

std::wstring Name;

std::wstring Path;

bool Removable;

uint64 Size;

uint32 SystemNumber;

BYTE VolumeIDs[TC_VOLUME_TYPE_COUNT][VOLUME_ID_SIZE];

bool HasVolumeIDs;

std::vector <HostDevice> Partitions;

};

struct RawDevicesDlgParam

{

std::vector <HostDevice> devices;

wchar_t *pszFileName;

};

BOOL BrowseFilesInDir (HWND hwndDlg, char *stringId, wchar_t *initialDir, wchar_t *lpszFileName, BOOL keepHistory, BOOL saveMode, wchar_t *browseFilter, const wchar_t *initialFileName = NULL, const wchar_t *defaultExtension = NULL);

std::wstring SingleStringToWide (const std::string &singleString);

std::wstring Utf8StringToWide (const std::string &utf8String);

std::string WideToUtf8String (const std::wstring &wideString);

std::vector <HostDevice> GetAvailableHostDevices (bool noDeviceProperties = false, bool singleList = false, bool noFloppy = true, bool detectUnencryptedFilesystems = false);

std::wstring ToUpperCase (const std::wstring &str);

std::wstring GetWrongPasswordErrorMessage (HWND hwndDlg);

std::wstring GetWindowsEdition ();

std::wstring FitPathInGfxWidth (HWND hwnd, HFONT hFont, LONG width, const std::wstring &path);

std::wstring GetServiceConfigPath (const wchar_t *fileName, bool useLegacy);

std::wstring VolumeGuidPathToDevicePath (std::wstring volumeGuidPath);

std::wstring HarddiskVolumePathToPartitionPath (const std::wstring &harddiskVolumePath);

std::wstring FindLatestFileOrDirectory (const std::wstring &directory, const wchar_t *namePattern, bool findDirectory, bool findFile);

std::wstring GetUserFriendlyVersionString (int version);

std::wstring IntToWideString (int val);

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

std::wstring FindDeviceByVolumeID (const BYTE volumeID [VOLUME_ID_SIZE], BOOL bFromService);

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

std::wstring GetTempPathString ();

void CorrectFileName (std::wstring& fileName);

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

{

return std::wstring (msg? msg : L"") + L"\n\nSource: " + SingleStringToWide (srcPos);

}

void UpdateMountableHostDeviceList ();

INT_PTR TextEditDialogBox (BOOL readOnly, HWND parent, const WCHAR* Title, std::string& text);

// Display a wait dialog while calling the provided callback with the given parameter

typedef void (CALLBACK* WaitThreadProc)(void* pArg, HWND hWaitDlg);

void BringToForeground(HWND hWnd);

void ShowWaitDialog(HWND hwnd, BOOL bUseHwndAsParent, WaitThreadProc callback, void* pArg);

// classes used to implement support for password drag-n-drop from KeePass Password Safe

// Implementation based the following source code with many modifications to fix isses and add features

// URL: https://www.codeguru.com/cpp/misc/misc/draganddrop/article.php/c349/Drag-And-Drop-between-Window-Controls.htm

interface GenericDropTarget : public IDropTarget

{

public:

GenericDropTarget(CLIPFORMAT* pFormats, size_t count);

~GenericDropTarget();

// basic IUnknown stuff

HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject);

ULONG STDMETHODCALLTYPE AddRef(void);

ULONG STDMETHODCALLTYPE Release(void);