+/*

+ Copyright (c) 2010 TrueCrypt Developers Association. All rights reserved.

+

+ Governed by the TrueCrypt License 3.0 the full text of which is contained in

+ the file License.txt included in TrueCrypt binary and source code distribution

+ packages.

+*/

+

+#include "Tcdefs.h"

+#include "Platform/Finally.h"

+#include "Platform/ForEach.h"

+#include "BootEncryption.h"

+#include "Dlgcode.h"

+#include "Language.h"

+#include "Mount.h"

+#include "Resource.h"

+#include "Xml.h"

+#include "Favorites.h"

+

+using namespace std;

+

+namespace TrueCrypt

+{

+ vector <FavoriteVolume> FavoriteVolumes;

+ vector <FavoriteVolume> SystemFavoriteVolumes;

+ list <FavoriteVolume> FavoritesOnArrivalMountRequired;

+ list <FavoriteVolume> FavoritesMountedOnArrivalStillConnected;

+ HMENU FavoriteVolumesMenu;

+

+

+ BOOL AddMountedVolumeToFavorites (HWND hwndDlg, int driveNo, bool systemFavorites)

+ {

+ VOLUME_PROPERTIES_STRUCT prop;

+ DWORD bytesReturned;

+

+ memset (&prop, 0, sizeof (prop));

+ prop.driveNo = driveNo;

+

+ if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &bytesReturned, NULL))

+ {

+ handleWin32Error (hwndDlg);

+ return FALSE;

+ }

+

+ FavoriteVolume favorite;

+ favorite.MountPoint = "X:\\";

+ favorite.MountPoint[0] = (char) (prop.driveNo + 'A');

+

+ favorite.Path = WideToSingleString ((wchar_t *) prop.wszVolume);

+ if (favorite.Path.find ("\\??\\") == 0)

+ favorite.Path = favorite.Path.substr (4);

+

+ if (IsVolumeDeviceHosted (favorite.Path.c_str()))

+ {

+ // Get GUID path

+ string volumeDevPath = favorite.Path;

+

+ wchar_t resolvedVolumeDevPath[TC_MAX_PATH];

+ if (ResolveSymbolicLink (SingleStringToWide (volumeDevPath).c_str(), resolvedVolumeDevPath))

+ volumeDevPath = WideToSingleString (resolvedVolumeDevPath);

+

+ char volumeName[TC_MAX_PATH];

+ HANDLE find = FindFirstVolume (volumeName, sizeof (volumeName));

+

+ if (find != INVALID_HANDLE_VALUE)

+ {

+ do

+ {

+ char findVolumeDevPath[TC_MAX_PATH];

+ string vn = volumeName;

+

+ if (QueryDosDevice (vn.substr (4, vn.size() - 5).c_str(), findVolumeDevPath, sizeof (findVolumeDevPath)) != 0

+ && volumeDevPath == findVolumeDevPath)

+ {

+ favorite.VolumePathId = volumeName;

+ break;

+ }

+

+ } while (FindNextVolume (find, volumeName, sizeof (volumeName)));

+

+ FindVolumeClose (find);

+ }

+ }

+

+ favorite.ReadOnly = prop.readOnly ? true : false;

+ favorite.Removable = prop.removable ? true : false;

+ favorite.SystemEncryption = prop.partitionInInactiveSysEncScope ? true : false;

+ favorite.OpenExplorerWindow = (bExplore == TRUE);

+

+ if (favorite.VolumePathId.empty()

+ && IsVolumeDeviceHosted (favorite.Path.c_str())

+ && favorite.Path.find ("\\\\?\\Volume{") != 0)

+ {

+ Warning (favorite.Path.find ("\\Partition0") == string::npos ? "FAVORITE_ADD_PARTITION_TYPE_WARNING" : "FAVORITE_ADD_DRIVE_DEV_WARNING");

+ }

+

+ return OrganizeFavoriteVolumes (hwndDlg, systemFavorites, favorite);

+ }

+

+

+ static BOOL CALLBACK FavoriteVolumesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+ {

+ /* This dialog is used both for System Favorites and non-system Favorites.

+

+ The following options have different meaning in System Favorites mode:

+

+ IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT => MOUNT_SYSTEM_FAVORITES_ON_BOOT

+ IDC_FAVORITE_DISABLE_HOTKEY => DISABLE_NONADMIN_SYS_FAVORITES_ACCESS

+

+ */

+

+ WORD lw = LOWORD (wParam);

+ static bool SystemFavoritesMode;

+ static vector <FavoriteVolume> Favorites;

+ static int SelectedItem;

+ static HWND FavoriteListControl;

+

+ switch (msg)

+ {

+ case WM_INITDIALOG:

+ {

+ try

+ {

+ FavoriteListControl = GetDlgItem (hwndDlg, IDC_FAVORITE_VOLUMES_LIST);

+

+ FavoriteVolumesDlgProcArguments *args = (FavoriteVolumesDlgProcArguments *) lParam;

+ SystemFavoritesMode = args->SystemFavorites;

+

+ LocalizeDialog (hwndDlg, SystemFavoritesMode ? "SYSTEM_FAVORITES_DLG_TITLE" : "IDD_FAVORITE_VOLUMES");

+

+ if (SystemFavoritesMode)

+ {

+ RECT rec;

+

+ BootEncryptionStatus bootEncStatus = BootEncryption (hwndDlg).GetStatus();

+

+ if (!bootEncStatus.DriveMounted)

+ throw ErrorException ("SYS_FAVORITES_REQUIRE_PBA");

+

+ ShowWindow (GetDlgItem(hwndDlg, IDC_FAVORITE_MOUNT_ON_LOGON), SW_HIDE);

+ ShowWindow (GetDlgItem(hwndDlg, IDC_FAVORITE_MOUNT_ON_ARRIVAL), SW_HIDE);

+

+ // MOUNT_SYSTEM_FAVORITES_ON_BOOT

+

+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT), GetString ("MOUNT_SYSTEM_FAVORITES_ON_BOOT"));

+

+ // DISABLE_NONADMIN_SYS_FAVORITES_ACCESS

+

+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY), GetString ("DISABLE_NONADMIN_SYS_FAVORITES_ACCESS"));

+

+ // Group box

+

+ GetClientRect (GetDlgItem (hwndDlg, IDC_FAV_VOL_OPTIONS_GROUP_BOX), &rec);

+

+ SetWindowPos (GetDlgItem (hwndDlg, IDC_FAV_VOL_OPTIONS_GROUP_BOX), 0, 0, 0,

+ rec.right,

+ rec.bottom - CompensateYDPI (90),

+ SWP_NOMOVE | SWP_NOZORDER);

+

+ InvalidateRect (GetDlgItem (hwndDlg, IDC_FAV_VOL_OPTIONS_GROUP_BOX), NULL, TRUE);

+ }

+ else

+ {

+ ShowWindow (GetDlgItem(hwndDlg, IDC_FAV_VOL_OPTIONS_GLOBAL_SETTINGS_BOX), SW_HIDE);

+ }

+

+ Favorites.clear();

+

+ LVCOLUMNW column;

+ SendMessageW (FavoriteListControl, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);

+

+ memset (&column, 0, sizeof (column));

+ column.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

+ column.pszText = GetString ("DRIVE");

+ column.cx = CompensateXDPI (38);

+ column.fmt = LVCFMT_CENTER;

+ SendMessageW (FavoriteListControl, LVM_INSERTCOLUMNW, 1, (LPARAM) &column);

+

+ ++column.iSubItem;

+ column.fmt = LVCFMT_LEFT;

+ column.pszText = GetString ("LABEL");

+ column.cx = CompensateXDPI (160);

+ SendMessageW (FavoriteListControl, LVM_INSERTCOLUMNW, 2, (LPARAM) &column);

+

+ ++column.iSubItem;

+ column.fmt = LVCFMT_LEFT;

+ column.pszText = GetString ("VOLUME");

+ column.cx = CompensateXDPI (330);

+ SendMessageW (FavoriteListControl, LVM_INSERTCOLUMNW, 3, (LPARAM) &column);

+

+ SetControls (hwndDlg, FavoriteVolume(), SystemFavoritesMode, false);

+

+ if (SystemFavoritesMode)

+ LoadFavoriteVolumes (Favorites, true);

+ else

+ Favorites = FavoriteVolumes;

+

+ if (args->AddFavoriteVolume)

+ Favorites.push_back (args->NewFavoriteVolume);

+

+ FillListControl (FavoriteListControl, Favorites);

+

+ SelectedItem = -1;

+

+ if (args->AddFavoriteVolume)

+ {

+ ListView_SetItemState (FavoriteListControl, Favorites.size() - 1, LVIS_SELECTED, LVIS_SELECTED);

+ ListView_EnsureVisible (FavoriteListControl, Favorites.size() - 1, FALSE);

+ }

+

+ if (SystemFavoritesMode)

+ SetDlgItemTextW (hwndDlg, IDC_FAVORITES_HELP_LINK, GetString ("SYS_FAVORITES_HELP_LINK"));

+

+ ToHyperlink (hwndDlg, IDC_FAVORITES_HELP_LINK);

+ }

+ catch (Exception &e)

+ {

+ e.Show (hwndDlg);

+ EndDialog (hwndDlg, IDCLOSE);

+ }

+ }

+ return 1;

+

+ case WM_COMMAND:

+

+ switch (lw)

+ {

+ case IDOK:

+

+ /* Global System Favorites settings */

+

+ if (SystemFavoritesMode)

+ {

+ BootEncryption BootEncObj (NULL);

+

+ if (BootEncObj.GetStatus().DriveMounted)

+ {

+ try

+ {

+ uint32 reqConfig = IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT) ? TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD_FOR_SYS_FAVORITES : 0;

+ if (reqConfig != (ReadDriverConfigurationFlags() & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD_FOR_SYS_FAVORITES))

+ BootEncObj.RegisterSystemFavoritesService (reqConfig ? TRUE : FALSE);

+

+ SetDriverConfigurationFlag (TC_DRIVER_CONFIG_DISABLE_NONADMIN_SYS_FAVORITES_ACCESS, IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY));

+ }

+ catch (Exception &e)

+ {

+ e.Show (hwndDlg);

+ }

+ }

+ }

+

+ /* (System) Favorites list */

+

+ if (SelectedItem != -1 && !Favorites.empty())

+ SetFavoriteVolume (hwndDlg, Favorites[SelectedItem], SystemFavoritesMode);

+

+ if (SaveFavoriteVolumes (Favorites, SystemFavoritesMode))

+ {

+ if (!SystemFavoritesMode)

+ {

+ bMountFavoritesOnLogon = FALSE;

+

+ foreach (const FavoriteVolume &favorite, Favorites)

+ {

+ if (favorite.MountOnLogOn)

+ {

+ bMountFavoritesOnLogon = TRUE;

+ break;

+ }

+ }

+

+ if (!bEnableBkgTask || bCloseBkgTaskWhenNoVolumes || IsNonInstallMode())

+ {

+ foreach (const FavoriteVolume favorite, Favorites)

+ {

+ if (favorite.MountOnArrival)

+ {

+ Warning ("FAVORITE_ARRIVAL_MOUNT_BACKGROUND_TASK_ERR");

+ break;

+ }

+ }

+ }

+

+ FavoriteVolumes = Favorites;

+

+ ManageStartupSeq();

+ SaveSettings (hwndDlg);

+ }

+ else

+ SystemFavoriteVolumes = Favorites;

+

+ OnFavoriteVolumesUpdated();

+ LoadDriveLetters (GetDlgItem (MainDlg, IDC_DRIVELIST), 0);

+

+ EndDialog (hwndDlg, IDOK);

+ }

+

+ return 1;

+

+ case IDCANCEL:

+ EndDialog (hwndDlg, IDCLOSE);

+ return 1;

+

+ case IDC_FAVORITE_MOVE_DOWN:

+ if (SelectedItem != -1 && Favorites.size() > (size_t) SelectedItem + 1)

+ {

+ swap (Favorites[SelectedItem], Favorites[SelectedItem + 1]);

+

+ FillListControl (FavoriteListControl, Favorites);

+ ++SelectedItem;

+ ListView_SetItemState (FavoriteListControl, SelectedItem, LVIS_SELECTED, LVIS_SELECTED);

+ ListView_EnsureVisible (FavoriteListControl, SelectedItem, FALSE);

+ }

+ return 1;

+

+ case IDC_FAVORITE_MOVE_UP:

+ if (SelectedItem > 0)

+ {

+ swap (Favorites[SelectedItem], Favorites[SelectedItem - 1]);

+

+ FillListControl (FavoriteListControl, Favorites);

+ --SelectedItem;

+ ListView_SetItemState (FavoriteListControl, SelectedItem, LVIS_SELECTED, LVIS_SELECTED);

+ ListView_EnsureVisible (FavoriteListControl, SelectedItem, FALSE);

+ }

+ return 1;

+

+ case IDC_FAVORITE_REMOVE:

+ if (SelectedItem != -1)

+ {

+ Favorites.erase (Favorites.begin() + SelectedItem);

+ FillListControl (GetDlgItem (hwndDlg, IDC_FAVORITE_VOLUMES_LIST), Favorites);

+ SetControls (hwndDlg, FavoriteVolume(), SystemFavoritesMode, false);

+ SelectedItem = -1;

+ }

+ return 1;

+

+

+ case IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT: // Note that this option means "MOUNT_SYSTEM_FAVORITES_ON_BOOT" when SystemFavoritesMode is true

+ if (SystemFavoritesMode)

+ {

+ // MOUNT_SYSTEM_FAVORITES_ON_BOOT

+

+ if (IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT))

+ {

+ WarningDirect ((wstring (GetString ("SYS_FAVORITES_KEYBOARD_WARNING")) + L"\n\n" + GetString ("BOOT_PASSWORD_CACHE_KEYBOARD_WARNING")).c_str());

+

+ if (!IsServerOS() && !IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY))

+ Info ("SYS_FAVORITES_ADMIN_ONLY_INFO");

+ }

+ }

+ return 1;

+

+ case IDC_FAVORITE_DISABLE_HOTKEY: // Note that this option means "DISABLE_NONADMIN_SYS_FAVORITES_ACCESS" when SystemFavoritesMode is true

+ if (SystemFavoritesMode)

+ {

+ // DISABLE_NONADMIN_SYS_FAVORITES_ACCESS

+

+ if (IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY))

+ WarningDirect ((wstring (GetString ("SYS_FAVORITES_ADMIN_ONLY_WARNING")) + L"\n\n" + GetString ("SETTING_REQUIRES_REBOOT")).c_str());

+ else

+ Warning ("SETTING_REQUIRES_REBOOT");

+ }

+ return 1;

+

+ case IDC_FAVORITES_HELP_LINK:

+ Applink (SystemFavoritesMode ? "sysfavorites" : "favorites", TRUE, "");

+ return 1;

+ }

+

+ return 0;

+

+ case WM_NOTIFY:

+ if (((LPNMHDR) lParam)->code == LVN_ITEMCHANGED)

+ {

+ static bool reentry = false;

+ if (reentry)

+ break;

+

+ reentry = true;

+

+ if (SelectedItem != -1)

+ {

+ SetFavoriteVolume (hwndDlg, Favorites[SelectedItem], SystemFavoritesMode);

+ FillListControlSubItems (FavoriteListControl, SelectedItem, Favorites[SelectedItem]);

+ }

+

+ SelectedItem = ListView_GetNextItem (GetDlgItem (hwndDlg, IDC_FAVORITE_VOLUMES_LIST), -1, LVIS_SELECTED);

+

+ if (SelectedItem != -1)

+ SetControls (hwndDlg, Favorites[SelectedItem], SystemFavoritesMode);

+ else

+ SetControls (hwndDlg, FavoriteVolume(), SystemFavoritesMode, false);

+

+ reentry = false;

+ return 1;

+ }

+ break;

+

+ case WM_CLOSE:

+ EndDialog (hwndDlg, IDCLOSE);

+ return 1;

+ }

+

+ return 0;

+ }

+

+

+ static void FillFavoriteVolumesMenu ()

+ {

+ while (DeleteMenu (FavoriteVolumesMenu, 7, MF_BYPOSITION)) { }

+

+ if (FavoriteVolumes.empty())

+ return;

+

+ AppendMenu (FavoriteVolumesMenu, MF_SEPARATOR, 0, NULL);

+

+ int i = 0;

+ foreach (const FavoriteVolume &favorite, FavoriteVolumes)

+ {

+ UINT flags = MF_STRING;

+

+ if (favorite.DisconnectedDevice)

+ flags |= MF_GRAYED;

+

+ wstring menuText = SingleStringToWide (favorite.Path);

+ if (favorite.DisconnectedDevice)

+ menuText = favorite.Label.empty() ? wstring (L"(") + GetString ("FAVORITE_DISCONNECTED_DEV") + L")" : L"";

+

+ if (!favorite.Label.empty())

+ {

+ if (favorite.DisconnectedDevice)

+ menuText = favorite.Label + L" " + menuText;

+ else

+ menuText = favorite.Label;

+ }

+

+ AppendMenuW (FavoriteVolumesMenu, flags, TC_FAVORITE_MENU_CMD_ID_OFFSET + i++,

+ (menuText + L"\t" + SingleStringToWide (favorite.MountPoint).substr (0, 2)).c_str());

+ }

+ }

+

+

+ static void FillListControl (HWND favoriteListControl, vector <FavoriteVolume> &favorites)

+ {

+ SendMessage (favoriteListControl, LVM_DELETEALLITEMS, 0, 0);

+

+ int line = 0;

+ foreach (const FavoriteVolume favorite, favorites)

+ {

+ ListItemAdd (favoriteListControl, line, (char *) favorite.MountPoint.substr (0, 2).c_str());

+ FillListControlSubItems (favoriteListControl, line++, favorite);

+ }

+ }

+

+

+ static void FillListControlSubItems (HWND FavoriteListControl, int line, const FavoriteVolume &favorite)

+ {

+ ListSubItemSetW (FavoriteListControl, line, 1, (wchar_t *) favorite.Label.c_str());

+

+ if (favorite.DisconnectedDevice)

+ ListSubItemSetW (FavoriteListControl, line, 2, (wchar_t *) (wstring (L"(") + GetString ("FAVORITE_DISCONNECTED_DEV") + L")").c_str());

+ else

+ ListSubItemSet (FavoriteListControl, line, 2, (char *) favorite.Path.c_str());

+ }

+

+

+ wstring GetFavoriteVolumeLabel (const string &volumePath)

+ {

+ foreach (const FavoriteVolume &favorite, FavoriteVolumes)

+ {

+ if (favorite.Path == volumePath)

+ return favorite.Label;

+ }

+

+ foreach (const FavoriteVolume &favorite, SystemFavoriteVolumes)

+ {

+ if (favorite.Path == volumePath)

+ return favorite.Label;

+ }

+

+ return wstring();

+ }

+

+

+ void LoadFavoriteVolumes ()

+ {

+ LoadFavoriteVolumes (FavoriteVolumes, false);

+

+ try

+ {

+ LoadFavoriteVolumes (SystemFavoriteVolumes, true, true);

+ }

+ catch (...) { } // Ignore errors as SystemFavoriteVolumes list is used only for resolving volume paths to labels

+

+ OnFavoriteVolumesUpdated();

+ }

+

+

+ void LoadFavoriteVolumes (vector <FavoriteVolume> &favorites, bool systemFavorites, bool noUacElevation)

+ {

+ favorites.clear();

+ string favoritesFilePath = systemFavorites ? GetServiceConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES) : GetConfigPath (TC_APPD_FILENAME_FAVORITE_VOLUMES);

+

+ if (systemFavorites && !IsAdmin() && !noUacElevation)

+ {

+ favoritesFilePath = GetConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES);

+

+ try

+ {

+ BootEncryption bootEnc (MainDlg);

+ bootEnc.CopyFileAdmin (GetServiceConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES).c_str(), favoritesFilePath.c_str());

+ }

+ catch (SystemException &e)

+ {

+ if (e.ErrorCode == ERROR_FILE_NOT_FOUND)

+ return;

+

+ throw;

+ }

+ }

+

+ DWORD size;

+ char *favoritesXml = LoadFile (favoritesFilePath.c_str(), &size);

+

+ if (systemFavorites && !IsAdmin() && !noUacElevation)

+ DeleteFile (GetConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES));

+

+ char *xml = favoritesXml;

+ char mountPoint[MAX_PATH], volume[MAX_PATH];

+

+ if (xml == NULL)

+ return;

+

+ while (xml = XmlFindElement (xml, "volume"))

+ {

+ FavoriteVolume favorite;

+

+ XmlGetAttributeText (xml, "mountpoint", mountPoint, sizeof (mountPoint));

+ favorite.MountPoint = mountPoint;

+

+ XmlGetNodeText (xml, volume, sizeof (volume));

+ favorite.Path = WideToSingleString (Utf8StringToWide (volume));

+

+ char label[1024];

+ XmlGetAttributeText (xml, "label", label, sizeof (label));

+ favorite.Label = Utf8StringToWide (label);

+

+ char boolVal[2];

+ XmlGetAttributeText (xml, "readonly", boolVal, sizeof (boolVal));

+ if (boolVal[0])

+ favorite.ReadOnly = (boolVal[0] == '1');

+

+ XmlGetAttributeText (xml, "removable", boolVal, sizeof (boolVal));

+ if (boolVal[0])

+ favorite.Removable = (boolVal[0] == '1');

+

+ XmlGetAttributeText (xml, "system", boolVal, sizeof (boolVal));

+ if (boolVal[0])

+ favorite.SystemEncryption = (boolVal[0] == '1');

+

+ XmlGetAttributeText (xml, "noHotKeyMount", boolVal, sizeof (boolVal));

+ if (boolVal[0])

+ favorite.DisableHotkeyMount = (boolVal[0] == '1');

+

+ XmlGetAttributeText (xml, "openExplorerWindow", boolVal, sizeof (boolVal));

+ if (boolVal[0])

+ favorite.OpenExplorerWindow = (boolVal[0] == '1');

+

+ XmlGetAttributeText (xml, "mountOnArrival", boolVal, sizeof (boolVal));

+ if (boolVal[0])

+ favorite.MountOnArrival = (boolVal[0] == '1');

+

+ XmlGetAttributeText (xml, "mountOnLogOn", boolVal, sizeof (boolVal));

+ if (boolVal[0])

+ favorite.MountOnLogOn = (boolVal[0] == '1');

+

+ if (favorite.Path.find ("\\\\?\\Volume{") == 0 && favorite.Path.rfind ("}\\") == favorite.Path.size() - 2)

+ {

+ string resolvedPath = VolumeGuidPathToDevicePath (favorite.Path);

+ if (!resolvedPath.empty())

+ {

+ favorite.DisconnectedDevice = false;

+ favorite.VolumePathId = favorite.Path;

+ favorite.Path = resolvedPath;

+ }

+ else

+ favorite.DisconnectedDevice = true;

+ }

+

+ favorites.push_back (favorite);

+ xml++;

+ }

+

+ free (favoritesXml);

+ }

+

+

+ static void OnFavoriteVolumesUpdated ()

+ {

+ FillFavoriteVolumesMenu();

+

+ FavoritesOnArrivalMountRequired.clear();

+

+ foreach (const FavoriteVolume favorite, FavoriteVolumes)

+ {

+ if (favorite.MountOnArrival)

+ {

+ FavoritesOnArrivalMountRequired.push_back (favorite);

+

+ if (IsMountedVolume (favorite.Path.c_str()))

+ {

+ bool present = false;

+

+ foreach (const FavoriteVolume favoriteConnected, FavoritesMountedOnArrivalStillConnected)

+ {

+ if (favorite.Path == favoriteConnected.Path)

+ {

+ present = true;

+ break;

+ }

+ }

+

+ if (!present)

+ FavoritesMountedOnArrivalStillConnected.push_back (favorite);

+ }

+ }

+ }

+ }

+

+

+ BOOL OrganizeFavoriteVolumes (HWND hwndDlg, bool systemFavorites, const FavoriteVolume &newFavorite)

+ {

+ FavoriteVolumesDlgProcArguments args;

+ args.SystemFavorites = systemFavorites;

+

+ if (!newFavorite.Path.empty())

+ {

+ args.AddFavoriteVolume = true;

+ args.NewFavoriteVolume = newFavorite;

+ }

+ else

+ args.AddFavoriteVolume = false;

+

+ return DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_FAVORITE_VOLUMES), hwndDlg, (DLGPROC) FavoriteVolumesDlgProc, (LPARAM) &args) == IDOK;

+ }

+

+

+ static bool SaveFavoriteVolumes (const vector <FavoriteVolume> &favorites, bool systemFavorites)

+ {

+ FILE *f;

+ int cnt = 0;

+

+ f = fopen (GetConfigPath (systemFavorites ? TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES : TC_APPD_FILENAME_FAVORITE_VOLUMES), "w,ccs=UTF-8");

+ if (f == NULL)

+ {

+ handleWin32Error (MainDlg);

+ return false;

+ }

+

+ XmlWriteHeaderW (f);

+ fputws (L"\n\t<favorites>", f);

+

+ foreach (const FavoriteVolume &favorite, favorites)

+ {

+ char tq[2048];

+

+ if (systemFavorites && favorite.Path.find ("\\\\") == 0 && favorite.Path.find ("Volume{") == string::npos)

+ Warning ("SYSTEM_FAVORITE_NETWORK_PATH_ERR");

+

+ XmlQuoteText (!favorite.VolumePathId.empty() ? favorite.VolumePathId.c_str() : favorite.Path.c_str(), tq, sizeof (tq));

+

+ wstring s = L"\n\t\t<volume mountpoint=\"" + SingleStringToWide (favorite.MountPoint) + L"\"";

+

+ if (!favorite.Label.empty())

+ s += L" label=\"" + favorite.Label + L"\"";

+

+ if (favorite.ReadOnly)

+ s += L" readonly=\"1\"";

+

+ if (favorite.Removable)

+ s += L" removable=\"1\"";

+

+ if (favorite.SystemEncryption)

+ s += L" system=\"1\"";

+

+ if (favorite.MountOnArrival)

+ s += L" mountOnArrival=\"1\"";

+

+ if (favorite.MountOnLogOn)

+ s += L" mountOnLogOn=\"1\"";

+

+ if (favorite.DisableHotkeyMount)

+ s += L" noHotKeyMount=\"1\"";

+

+ if (favorite.OpenExplorerWindow)

+ s += L" openExplorerWindow=\"1\"";

+

+ s += L">" + SingleStringToWide (tq) + L"</volume>";

+

+ fwprintf (f, L"%ws", s.c_str());

+ cnt++;

+ }

+

+ fputws (L"\n\t</favorites>", f);

+ XmlWriteFooterW (f);

+

+ if (!CheckFileStreamWriteErrors (f, systemFavorites ? TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES : TC_APPD_FILENAME_FAVORITE_VOLUMES))

+ {

+ fclose (f);

+ return false;

+ }

+

+ fclose (f);

+

+ BootEncryption bootEnc (MainDlg);

+

+ if (systemFavorites)

+ {

+ finally_do ({ remove (GetConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES)); });

+

+ try

+ {

+ bootEnc.DeleteFileAdmin (GetServiceConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES).c_str());

+ }

+ catch (UserAbort&) { return false; }

+ catch (...) { }

+

+ try

+ {

+ if (cnt != 0)

+ {

+ bootEnc.CopyFileAdmin (GetConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES), GetServiceConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES).c_str());

+

+ if (!(ReadDriverConfigurationFlags() & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD_FOR_SYS_FAVORITES))

+ Info ("SYS_FAVORITE_VOLUMES_SAVED");

+ }

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ }

+ }

+

+ if (cnt == 0)

+ {

+ if (systemFavorites)

+ {

+ try

+ {

+ bootEnc.DeleteFileAdmin (GetServiceConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES).c_str());

+ }

+ catch (...) { }

+ }

+ else

+ remove (GetConfigPath (TC_APPD_FILENAME_FAVORITE_VOLUMES));

+ }

+

+ return true;

+ }

+

+

+ static void SetControls (HWND hwndDlg, const FavoriteVolume &favorite, bool systemFavoritesMode, bool enable)

+ {

+ SetDlgItemTextW (hwndDlg, IDC_FAVORITE_LABEL, favorite.Label.c_str());

+ SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_ON_LOGON, favorite.MountOnLogOn);

+ SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_ON_ARRIVAL, favorite.MountOnArrival);

+ SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_READONLY, favorite.ReadOnly);

+ SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_REMOVABLE, favorite.Removable);

+

+ if (systemFavoritesMode)

+ {

+ uint32 driverConfig = ReadDriverConfigurationFlags();

+

+ // MOUNT_SYSTEM_FAVORITES_ON_BOOT

+ CheckDlgButton (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT, (driverConfig & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD_FOR_SYS_FAVORITES) ? BST_CHECKED : BST_UNCHECKED);

+

+ // DISABLE_NONADMIN_SYS_FAVORITES_ACCESS

+ CheckDlgButton (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY, (driverConfig & TC_DRIVER_CONFIG_DISABLE_NONADMIN_SYS_FAVORITES_ACCESS) ? BST_CHECKED : BST_UNCHECKED);

+ }

+ else

+ {

+ SetCheckBox (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT, favorite.OpenExplorerWindow);

+ SetCheckBox (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY, favorite.DisableHotkeyMount);

+ }

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_MOVE_UP), enable);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_MOVE_DOWN), enable);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_REMOVE), enable);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_FAVORITE_LABEL), enable);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_LABEL), enable);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_MOUNT_ON_LOGON), enable && !systemFavoritesMode);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_MOUNT_ON_ARRIVAL), enable && !systemFavoritesMode);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_MOUNT_READONLY), enable);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_MOUNT_REMOVABLE), enable);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT), enable || systemFavoritesMode);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY), enable || systemFavoritesMode);

+ }

+

+

+ static void SetFavoriteVolume (HWND hwndDlg, FavoriteVolume &favorite, bool systemFavoritesMode)

+ {

+ wchar_t label[1024];

+ if (GetDlgItemTextW (hwndDlg, IDC_FAVORITE_LABEL, label, ARRAYSIZE (label)) != 0)

+ {

+ favorite.Label = label;

+

+ for (size_t i = 0; i < favorite.Label.size(); ++i)

+ {

+ if (favorite.Label[i] == L'"')

+ favorite.Label.at (i) = L'\'';

+ }

+ }

+ else

+ favorite.Label.clear();

+

+ favorite.ReadOnly = (IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_MOUNT_READONLY) != 0);

+ favorite.Removable = (IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_MOUNT_REMOVABLE) != 0);

+

+ if (!systemFavoritesMode)

+ {

+ favorite.MountOnLogOn = (IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_MOUNT_ON_LOGON) != 0);

+ favorite.MountOnArrival = (IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_MOUNT_ON_ARRIVAL) != 0);

+ favorite.DisableHotkeyMount = (IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY) != 0);

+ favorite.OpenExplorerWindow = (IsDlgButtonChecked (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT) != 0);

+ }

+

+ if (favorite.VolumePathId.empty()

+ && IsVolumeDeviceHosted (favorite.Path.c_str())

+ && favorite.Path.find ("\\\\?\\Volume{") != 0)

+ {

+ bool partition = (favorite.Path.find ("\\Partition0") == string::npos);

+

+ if (!favorite.Label.empty())

+ {

+ ErrorDirect ((GetString (partition ? "FAVORITE_LABEL_PARTITION_TYPE_ERR" : "FAVORITE_LABEL_DEVICE_PATH_ERR") + wstring (L"\n\n") + SingleStringToWide (favorite.Path)).c_str());

+ favorite.Label.clear();

+ }

+

+ if (favorite.MountOnArrival)

+ {

+ ErrorDirect ((GetString (partition ? "FAVORITE_ARRIVAL_MOUNT_PARTITION_TYPE_ERR" : "FAVORITE_ARRIVAL_MOUNT_DEVICE_PATH_ERR") + wstring (L"\n\n") + SingleStringToWide (favorite.Path)).c_str());

+ favorite.MountOnArrival = false;

+ }

+ }

+

+ if (favorite.MountOnArrival && favorite.Path.find ("\\\\") == 0 && favorite.Path.find ("Volume{") == string::npos)

+ {

+ Error ("FAVORITE_ARRIVAL_MOUNT_NETWORK_PATH_ERR");

+ favorite.MountOnArrival = false;

+ }

+ }

+

+

+ void UpdateDeviceHostedFavoriteVolumes ()

+ {

+ try

+ {

+ LoadFavoriteVolumes();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+ }

+}

+/*

+ Copyright (c) 2010 TrueCrypt Developers Association. All rights reserved.

+

+ Governed by the TrueCrypt License 3.0 the full text of which is contained in

+ the file License.txt included in TrueCrypt binary and source code distribution

+ packages.

+*/

+

+#ifndef TC_HEADER_Mount_FavoriteVolumes

+#define TC_HEADER_Mount_FavoriteVolumes

+

+#include <Tcdefs.h>

+

+namespace TrueCrypt

+{

+ struct FavoriteVolume

+ {

+ FavoriteVolume()

+ :

+ DisableHotkeyMount (false),

+ DisconnectedDevice (false),

+ MountOnLogOn (false),

+ MountOnArrival (false),

+ OpenExplorerWindow (false),

+ ReadOnly (false),

+ Removable (false),

+ SystemEncryption (false)

+ {

+ }

+

+ string Path;

+ string MountPoint;

+ string VolumePathId;

+ wstring Label;

+

+ bool DisableHotkeyMount;

+ bool DisconnectedDevice;

+ bool MountOnLogOn;

+ bool MountOnArrival;

+ bool OpenExplorerWindow;

+ bool ReadOnly;

+ bool Removable;

+ bool SystemEncryption;

+ };

+

+ struct FavoriteVolumesDlgProcArguments

+ {

+ bool SystemFavorites;

+ bool AddFavoriteVolume;

+ FavoriteVolume NewFavoriteVolume;

+ };

+

+ extern vector <FavoriteVolume> FavoriteVolumes;

+ extern list <FavoriteVolume> FavoritesOnArrivalMountRequired;

+ extern list <FavoriteVolume> FavoritesMountedOnArrivalStillConnected;

+ extern HMENU FavoriteVolumesMenu;

+

+ BOOL AddMountedVolumeToFavorites (HWND hwndDlg, int driveNo, bool systemFavorites);

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

+ static void FillFavoriteVolumesMenu ();

+ static void FillListControl (HWND favoriteListControl, vector <FavoriteVolume> &favorites);

+ static void FillListControlSubItems (HWND favoriteListControl, int line, const FavoriteVolume &favorite);

+ wstring GetFavoriteVolumeLabel (const string &volumePath);

+ void LoadFavoriteVolumes ();

+ void LoadFavoriteVolumes (vector <FavoriteVolume> &favorites, bool systemFavorites, bool noUacElevation = false);

+ static void OnFavoriteVolumesUpdated ();

+ BOOL OrganizeFavoriteVolumes (HWND hwndDlg, bool systemFavorites, const FavoriteVolume &newFavorite = FavoriteVolume());

+ static bool SaveFavoriteVolumes (const vector <FavoriteVolume> &favorites, bool systemFavorites);

+ static void SetControls (HWND hwndDlg, const FavoriteVolume &favorite, bool systemFavoritesMode, bool enable = true);

+ static void SetFavoriteVolume (HWND hwndDlg, FavoriteVolume &favorite, bool systemFavoritesMode);

+ void UpdateDeviceHostedFavoriteVolumes ();

+}

+

+#endif // TC_HEADER_Mount_FavoriteVolumes

+/*

+ Copyright (c) 2005 TrueCrypt Developers Association. All rights reserved.

+

+ Governed by the TrueCrypt License 3.0 the full text of which is contained in

+ the file License.txt included in TrueCrypt binary and source code distribution

+ packages.

+*/

+

+#include <windows.h>

+#include "Dlgcode.h"

+#include "Hotkeys.h"

+#include "Language.h"

+#include "Mount.h"

+#include "Resource.h"

+

+#define MAX_KEY_COMB_NAME_LEN 260

+

+TCHOTKEY Hotkeys [NBR_HOTKEYS];

+static TCHOTKEY tmpHotkeys [NBR_HOTKEYS];

+

+static int nSelectedHotkeyId;

+static UINT currentVKeyCode;

+

+

+static void ScanAndProcessKey (UINT *vKeyCode, wchar_t *keyName)

+{

+ UINT vKey;

+ *vKeyCode = 0;

+

+ for (vKey = 0; vKey <= 0xFF; vKey++)

+ {

+ if (GetAsyncKeyState (vKey) < 0)

+ {

+ if (GetKeyName (vKey, keyName)) // If the key is allowed and its name has been resolved

+ *vKeyCode = vKey;

+ }

+ }

+}

+

+

+/* Returns TRUE if the key is allowed and its name is resolved. */

+BOOL GetKeyName (UINT vKey, wchar_t *keyName)

+{

+ BOOL result = TRUE;

+

+ if (vKey >= 0x30 && vKey <= 0x5a)

+ {

+ // ASCII characters

+ wsprintfW (keyName, L"%hc", (char) vKey);

+ }

+ else if (vKey >= 0xE9 && vKey <= 0xF5)

+ {

+ // OEM-specific

+ wsprintfW (keyName, L"OEM-%d", vKey);

+ }

+ else if (vKey >= VK_F1 && vKey <= VK_F24)

+ {

+ // F1-F24

+ wsprintfW (keyName, L"F%d", vKey - VK_F1 + 1);

+ }

+ else if (vKey >= VK_NUMPAD0 && vKey <= VK_NUMPAD9)

+ {

+ // Numpad numbers

+ wsprintfW (keyName, L"%s %d", GetString ("VK_NUMPAD"), vKey - VK_NUMPAD0);

+ }

+ else

+ {

+ switch (vKey)

+ {

+ case VK_MULTIPLY: wsprintfW (keyName, L"%s *", GetString ("VK_NUMPAD")); break;

+ case VK_ADD: wsprintfW (keyName, L"%s +", GetString ("VK_NUMPAD")); break;

+ case VK_SEPARATOR: wsprintfW (keyName, L"%s Separator", GetString ("VK_NUMPAD")); break;

+ case VK_SUBTRACT: wsprintfW (keyName, L"%s -", GetString ("VK_NUMPAD")); break;

+ case VK_DECIMAL: wsprintfW (keyName, L"%s .", GetString ("VK_NUMPAD")); break;

+ case VK_DIVIDE: wsprintfW (keyName, L"%s /", GetString ("VK_NUMPAD")); break;

+ case VK_OEM_1: wcscpy (keyName, L"OEM 1 (';')"); break;

+ case VK_OEM_PLUS: wcscpy (keyName, L"+"); break;

+ case VK_OEM_COMMA: wcscpy (keyName, L","); break;

+ case VK_OEM_MINUS: wcscpy (keyName, L"-"); break;

+ case VK_OEM_PERIOD: wcscpy (keyName, L"."); break;

+ case VK_OEM_2: wcscpy (keyName, L"OEM 2 ('/')"); break;

+ case VK_OEM_3: wcscpy (keyName, L"OEM 3 (`)"); break;

+ case VK_OEM_4: wcscpy (keyName, L"OEM 4 ('[')"); break;

+ case VK_OEM_5: wcscpy (keyName, L"OEM 5 ('\\')"); break;

+ case VK_OEM_6: wcscpy (keyName, L"OEM 6 (']')"); break;

+ case VK_OEM_7: wcscpy (keyName, L"OEM 7 (')"); break;

+ case VK_OEM_8: wcscpy (keyName, L"OEM 8"); break;

+ case VK_OEM_AX: wcscpy (keyName, L"OEM AX"); break;

+ case VK_OEM_102: wcscpy (keyName, L"OEM 102"); break;

+ case VK_ICO_HELP: wcscpy (keyName, L"ICO_HELP"); break;

+ case VK_ICO_00: wcscpy (keyName, L"ICO_00"); break;

+ case VK_ICO_CLEAR: wcscpy (keyName, L"ICO_CLEAR"); break;

+ case VK_ATTN: wcscpy (keyName, L"Attn"); break;

+ case VK_CRSEL: wcscpy (keyName, L"CrSel"); break;

+ case VK_EXSEL: wcscpy (keyName, L"ExSel"); break;

+ case VK_EREOF: wcscpy (keyName, L"Erase EOF"); break;

+ case VK_PA1: wcscpy (keyName, L"PA1"); break;

+ case VK_OEM_CLEAR: wcscpy (keyName, L"OEM Clear"); break;

+

+ case 0:

+ case 1:

+ case 0xFF:

+ result = FALSE;

+ break;

+

+ default:

+ {

+ char key[16];

+ wchar_t *desc;

+ sprintf (key, "VKEY_%02X", vKey);

+ desc = GetString (key);

+ if (desc == UnknownString)

+ result = FALSE;

+ else

+ wcsncpy (keyName, desc, MAX_KEY_COMB_NAME_LEN);

+ }

+ }

+ }

+ return result;

+}

+

+

+static BOOL ShortcutInUse (UINT vKeyCode, UINT modifiers, TCHOTKEY hotkeys[])

+{

+ int i;

+

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

+ {

+ if (hotkeys[i].vKeyCode == vKeyCode && hotkeys[i].vKeyModifiers == modifiers)

+ return TRUE;

+ }

+ return FALSE;

+}

+

+

+void UnregisterAllHotkeys (HWND hwndDlg, TCHOTKEY hotkeys[])

+{

+ int i;

+

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

+ {

+ if (hotkeys[i].vKeyCode != 0)

+ UnregisterHotKey (hwndDlg, i);

+

+ }

+}

+

+

+BOOL RegisterAllHotkeys (HWND hwndDlg, TCHOTKEY hotkeys[])

+{

+ BOOL result = TRUE;

+ int i;

+

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

+ {

+ if (hotkeys[i].vKeyCode != 0

+ && !RegisterHotKey (hwndDlg, i, hotkeys[i].vKeyModifiers, hotkeys[i].vKeyCode))

+ result = FALSE;

+ }

+

+ return result;

+}

+

+

+static void DisplayHotkeyList (HWND hwndDlg)

+{

+ LVITEMW item;

+ HWND hList = GetDlgItem (hwndDlg, IDC_HOTKEY_LIST);

+ int i;

+ wchar_t ShortcutMod [MAX_KEY_COMB_NAME_LEN];

+ wchar_t ShortcutFinal [MAX_KEY_COMB_NAME_LEN*2];

+ wchar_t Shortcut [MAX_KEY_COMB_NAME_LEN];

+

+ SendMessage (hList, LVM_DELETEALLITEMS,0, (LPARAM)&item);

+

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

+ {

+ memset (&item,0,sizeof(item));

+ item.mask = LVIF_TEXT;

+ item.iItem = i;

+ item.iSubItem = 0;

+

+ switch (i)

+ {

+

+ case HK_AUTOMOUNT_DEVICES:

+ item.pszText = GetString ("HK_AUTOMOUNT_DEVICES");

+ break;

+

+ case HK_DISMOUNT_ALL:

+ item.pszText = GetString ("HK_DISMOUNT_ALL");

+ break;

+

+ case HK_WIPE_CACHE:

+ item.pszText = GetString ("HK_WIPE_CACHE");

+ break;

+

+ case HK_DISMOUNT_ALL_AND_WIPE:

+ item.pszText = GetString ("HK_DISMOUNT_ALL_AND_WIPE");

+ break;

+

+ case HK_FORCE_DISMOUNT_ALL_AND_WIPE:

+ item.pszText = GetString ("HK_FORCE_DISMOUNT_ALL_AND_WIPE");

+ break;

+

+ case HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT:

+ item.pszText = GetString ("HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT");

+ break;

+

+ case HK_MOUNT_FAVORITE_VOLUMES:

+ item.pszText = GetString ("HK_MOUNT_FAVORITE_VOLUMES");

+ break;

+

+ case HK_SHOW_HIDE_MAIN_WINDOW:

+ item.pszText = GetString ("HK_SHOW_HIDE_MAIN_WINDOW");

+ break;

+

+ case HK_CLOSE_SECURITY_TOKEN_SESSIONS:

+ item.pszText = GetString ("IDM_CLOSE_ALL_TOKEN_SESSIONS");

+ break;

+

+ default:

+ item.pszText = L"[?]";

+ }

+

+ SendMessageW (hList,LVM_INSERTITEMW,0,(LPARAM)&item);

+

+ item.iSubItem = 1;

+ wcscpy (Shortcut, L"");

+ wcscpy (ShortcutMod, L"");

+

+ if (GetKeyName (tmpHotkeys[i].vKeyCode, Shortcut))

+ {

+ if (tmpHotkeys[i].vKeyModifiers & MOD_CONTROL)

+ {

+ wcscat (ShortcutMod, GetString ("VK_CONTROL"));

+ wcscat (ShortcutMod, L"+");

+ }

+

+ if (tmpHotkeys[i].vKeyModifiers & MOD_SHIFT)

+ {

+ wcscat (ShortcutMod, GetString ("VK_SHIFT"));

+ wcscat (ShortcutMod, L"+");

+ }

+

+ if (tmpHotkeys[i].vKeyModifiers & MOD_ALT)

+ {

+ wcscat (ShortcutMod, GetString ("VK_ALT"));

+ wcscat (ShortcutMod, L"+");

+ }

+

+ if (tmpHotkeys[i].vKeyModifiers & MOD_WIN)

+ {

+ wcscat (ShortcutMod, GetString ("VK_WIN"));

+ wcscat (ShortcutMod, L"+");

+ }

+

+ wsprintfW (ShortcutFinal, L"%s%s", ShortcutMod, Shortcut);

+ item.pszText = ShortcutFinal;

+ }

+ else

+ item.pszText = L"";

+

+ SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&item);

+ }

+}

+

+

+

+BOOL CALLBACK HotkeysDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+{

+ HWND hList = GetDlgItem (hwndDlg, IDC_HOTKEY_LIST);

+ HWND hwndMainDlg = hwndDlg;

+ WORD lw = LOWORD (wParam);

+ WORD hw = HIWORD (wParam);

+ static BOOL bKeyScanOn;

+ static BOOL bTPlaySoundOnSuccessfulHkDismount;

+ static BOOL bTDisplayBalloonOnSuccessfulHkDismount;

+

+ while (GetParent (hwndMainDlg) != NULL)

+ {

+ hwndMainDlg = GetParent (hwndMainDlg);

+ }

+

+ switch (msg)

+ {

+ case WM_INITDIALOG:

+ {

+ LVCOLUMNW col;

+

+ bKeyScanOn = FALSE;

+ nSelectedHotkeyId = -1;

+ currentVKeyCode = 0;

+ memcpy (tmpHotkeys, Hotkeys, sizeof(tmpHotkeys));

+

+ SendMessageW (hList,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

+ LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_LABELTIP

+ );

+

+ memset (&col,0,sizeof(col));

+ col.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

+ col.pszText = GetString ("ACTION");

+ col.cx = CompensateXDPI (341);

+ col.fmt = LVCFMT_LEFT;

+ SendMessageW (hList,LVM_INSERTCOLUMNW,0,(LPARAM)&col);

+

+ col.pszText = GetString ("SHORTCUT");

+ col.cx = CompensateXDPI (190);

+ col.fmt = LVCFMT_LEFT;

+ SendMessageW (hList,LVM_INSERTCOLUMNW,1,(LPARAM)&col);

+

+ LocalizeDialog (hwndDlg, "IDD_HOTKEYS_DLG");

+

+ SetCheckBox (hwndDlg, IDC_HK_MOD_CTRL, TRUE);

+ SetCheckBox (hwndDlg, IDC_HK_MOD_SHIFT, FALSE);

+ SetCheckBox (hwndDlg, IDC_HK_MOD_ALT, TRUE);

+ SetCheckBox (hwndDlg, IDC_HK_MOD_WIN, FALSE);

+

+ SetCheckBox (hwndDlg, IDC_HK_DISMOUNT_PLAY_SOUND, bPlaySoundOnSuccessfulHkDismount);

+ SetCheckBox (hwndDlg, IDC_HK_DISMOUNT_BALLOON_TOOLTIP, bDisplayBalloonOnSuccessfulHkDismount);

+

+ bTPlaySoundOnSuccessfulHkDismount = bPlaySoundOnSuccessfulHkDismount;

+ bTDisplayBalloonOnSuccessfulHkDismount = bDisplayBalloonOnSuccessfulHkDismount;

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_ASSIGN), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_REMOVE), FALSE);

+

+ DisplayHotkeyList(hwndDlg);

+

+ SetTimer (hwndDlg, 0xfe, 10, NULL);

+ return 1;

+ }

+

+ case WM_TIMER:

+ {

+ if (nSelectedHotkeyId > -1)

+ {

+ wchar_t keyName [MAX_KEY_COMB_NAME_LEN];

+ UINT tmpVKeyCode;

+

+ keyName[0] = 0;

+

+ ScanAndProcessKey (&tmpVKeyCode, &keyName[0]);

+

+ if (keyName[0] != 0)

+ {

+ currentVKeyCode = tmpVKeyCode;

+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_HOTKEY_KEY), keyName);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_ASSIGN), TRUE);

+ }

+ }

+ return 1;

+ }

+

+ case WM_COMMAND:

+ case WM_NOTIFY:

+

+ if (lw == IDC_HOTKEY_KEY && hw == EN_CHANGE)

+ {

+ if (!bKeyScanOn && nSelectedHotkeyId < 0 && GetWindowTextLengthW (GetDlgItem (hwndDlg, IDC_HOTKEY_KEY)))

+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_HOTKEY_KEY), L"");

+ }

+

+ if (msg == WM_NOTIFY && wParam == IDC_HOTKEY_LIST)

+ {

+ if (((LPNMHDR) lParam)->code == LVN_ITEMACTIVATE

+ || ((LPNMHDR) lParam)->code == LVN_ITEMCHANGED && (((LPNMLISTVIEW) lParam)->uNewState & LVIS_FOCUSED))

+ {

+ LVITEM item;

+ memset(&item,0,sizeof(item));

+ nSelectedHotkeyId = ((LPNMLISTVIEW) lParam)->iItem;

+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_HOTKEY_KEY), GetString ("PRESS_A_KEY_TO_ASSIGN"));

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_REMOVE), (tmpHotkeys[nSelectedHotkeyId].vKeyCode > 0));

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_ASSIGN), FALSE);

+ bKeyScanOn = TRUE;

+ return 1;

+ }

+ }

+

+ if (lw == IDC_HOTKEY_ASSIGN)

+ {

+ BOOL bOwnActiveShortcut = FALSE;

+

+ if (nSelectedHotkeyId >= 0 && currentVKeyCode != 0)

+ {

+ UINT modifiers = 0;

+ if (GetCheckBox (hwndDlg, IDC_HK_MOD_CTRL))

+ modifiers = MOD_CONTROL;

+

+ if (GetCheckBox (hwndDlg, IDC_HK_MOD_ALT))

+ modifiers |= MOD_ALT;

+

+ if (GetCheckBox (hwndDlg, IDC_HK_MOD_SHIFT))

+ modifiers |= MOD_SHIFT;

+

+ if (GetCheckBox (hwndDlg, IDC_HK_MOD_WIN))

+ modifiers |= MOD_WIN;

+

+ // Check if it's not already assigned

+ if (ShortcutInUse (currentVKeyCode, modifiers, tmpHotkeys))

+ {

+ Error ("SHORTCUT_ALREADY_IN_USE");

+ return 1;

+ }

+

+ // Check for reserved system keys

+ switch (currentVKeyCode)

+ {

+ case VK_F1:

+ case VK_F12:

+ /* F1 is help and F12 is reserved for use by the debugger at all times */

+ if (modifiers == 0)

+ {

+ Error ("CANNOT_USE_RESERVED_KEY");

+ return 1;

+ }

+ break;

+ }

+

+ bOwnActiveShortcut = ShortcutInUse (currentVKeyCode, modifiers, Hotkeys);

+

+ // Test if the shortcut can be assigned without errors

+ if (!bOwnActiveShortcut

+ && !RegisterHotKey (hwndDlg, nSelectedHotkeyId, modifiers, currentVKeyCode))

+ {

+ handleWin32Error(hwndDlg);

+ return 1;

+ }

+ else

+ {

+ if (!bOwnActiveShortcut && !UnregisterHotKey (hwndDlg, nSelectedHotkeyId))

+ handleWin32Error(hwndDlg);

+

+ tmpHotkeys[nSelectedHotkeyId].vKeyCode = currentVKeyCode;

+ tmpHotkeys[nSelectedHotkeyId].vKeyModifiers = modifiers;

+

+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_HOTKEY_KEY), L"");

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_ASSIGN), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_REMOVE), FALSE);

+ nSelectedHotkeyId = -1;

+ bKeyScanOn = FALSE;

+ }

+ }

+ DisplayHotkeyList(hwndDlg);

+ return 1;

+ }

+

+ if (lw == IDC_HOTKEY_REMOVE)

+ {

+ if (nSelectedHotkeyId >= 0)

+ {

+ tmpHotkeys[nSelectedHotkeyId].vKeyCode = 0;

+ tmpHotkeys[nSelectedHotkeyId].vKeyModifiers = 0;

+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_HOTKEY_KEY), L"");

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_ASSIGN), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_REMOVE), FALSE);

+ nSelectedHotkeyId = -1;

+ bKeyScanOn = FALSE;

+ DisplayHotkeyList(hwndDlg);

+ }

+ return 1;

+ }

+

+ if (lw == IDC_RESET_HOTKEYS)

+ {

+ int i;

+

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

+ {

+ tmpHotkeys[i].vKeyCode = 0;

+ tmpHotkeys[i].vKeyModifiers = 0;

+ }

+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_HOTKEY_KEY), L"");

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_ASSIGN), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_HOTKEY_REMOVE), FALSE);

+ nSelectedHotkeyId = -1;

+ bKeyScanOn = FALSE;

+ DisplayHotkeyList(hwndDlg);

+ return 1;

+ }

+

+ if (lw == IDC_HK_DISMOUNT_PLAY_SOUND)

+ {

+ bTPlaySoundOnSuccessfulHkDismount = GetCheckBox (hwndDlg, IDC_HK_DISMOUNT_PLAY_SOUND);

+ }

+

+ if (lw == IDC_HK_DISMOUNT_BALLOON_TOOLTIP)

+ {

+ bTDisplayBalloonOnSuccessfulHkDismount = GetCheckBox (hwndDlg, IDC_HK_DISMOUNT_BALLOON_TOOLTIP);

+ }

+

+ if (lw == IDCANCEL || lw == IDCLOSE)

+ {

+ KillTimer (hwndDlg, 0xfe);

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+

+ if (lw == IDOK)

+ {

+ UnregisterAllHotkeys (hwndMainDlg, Hotkeys);

+ memcpy (Hotkeys, tmpHotkeys, sizeof(Hotkeys));

+ RegisterAllHotkeys (hwndMainDlg, Hotkeys);

+ KillTimer (hwndDlg, 0xfe);

+ bPlaySoundOnSuccessfulHkDismount = bTPlaySoundOnSuccessfulHkDismount;

+ bDisplayBalloonOnSuccessfulHkDismount = bTDisplayBalloonOnSuccessfulHkDismount;

+

+ SaveSettings (hwndDlg);

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+ return 0;

+

+ case WM_CLOSE:

+

+ KillTimer (hwndDlg, 0xfe);

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+ return 0;

+}

+

+

+/*

+ Copyright (c) 2005 TrueCrypt Developers Association. All rights reserved.

+

+ Governed by the TrueCrypt License 3.0 the full text of which is contained in

+ the file License.txt included in TrueCrypt binary and source code distribution

+ packages.

+*/

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+enum

+{

+ /* When adding/removing hot keys, update the following functions in Mount.c:

+ DisplayHotkeyList()

+ SaveSettings()

+ LoadSettings()

+ HandleHotKey() */

+

+ HK_AUTOMOUNT_DEVICES = 0,

+ HK_CLOSE_SECURITY_TOKEN_SESSIONS,

+ HK_DISMOUNT_ALL,

+ HK_DISMOUNT_ALL_AND_WIPE,

+ HK_FORCE_DISMOUNT_ALL_AND_WIPE,

+ HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT,

+ HK_MOUNT_FAVORITE_VOLUMES,

+ HK_SHOW_HIDE_MAIN_WINDOW,

+ HK_WIPE_CACHE,

+ NBR_HOTKEYS

+};

+

+typedef struct

+{

+ UINT vKeyCode;

+ UINT vKeyModifiers;

+} TCHOTKEY;

+

+extern TCHOTKEY Hotkeys [NBR_HOTKEYS];

+

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

+BOOL GetKeyName (UINT vKey, wchar_t *keyName);

+void UnregisterAllHotkeys (HWND hwndDlg, TCHOTKEY hotkeys[]);

+BOOL RegisterAllHotkeys (HWND hwndDlg, TCHOTKEY hotkeys[]);

+

+#ifdef __cplusplus

+}

+#endif

+/*

+ Copyright (c) 2007-2010 TrueCrypt Developers Association. All rights reserved.

+

+ Governed by the TrueCrypt License 3.0 the full text of which is contained in

+ the file License.txt included in TrueCrypt binary and source code distribution

+ packages.

+*/

+

+#include <atlcomcli.h>

+#include <atlconv.h>

+#include <windows.h>

+#include "BaseCom.h"

+#include "BootEncryption.h"

+#include "Dlgcode.h"

+#include "MainCom.h"

+#include "MainCom_h.h"

+#include "MainCom_i.c"

+#include "Mount.h"

+#include "Password.h"

+

+using namespace TrueCrypt;

+

+static volatile LONG ObjectCount = 0;

+

+class TrueCryptMainCom : public ITrueCryptMainCom

+{

+

+public:

+ TrueCryptMainCom (DWORD messageThreadId) : RefCount (0), MessageThreadId (messageThreadId)

+ {

+ InterlockedIncrement (&ObjectCount);

+ }

+

+ ~TrueCryptMainCom ()

+ {

+ if (InterlockedDecrement (&ObjectCount) == 0)

+ PostThreadMessage (MessageThreadId, WM_APP, 0, 0);

+ }

+

+ virtual ULONG STDMETHODCALLTYPE AddRef ()

+ {

+ return InterlockedIncrement (&RefCount);

+ }

+

+ virtual ULONG STDMETHODCALLTYPE Release ()

+ {

+ if (!InterlockedDecrement (&RefCount))

+ {

+ delete this;

+ return 0;

+ }

+

+ return RefCount;

+ }

+

+ virtual HRESULT STDMETHODCALLTYPE QueryInterface (REFIID riid, void **ppvObject)

+ {

+ if (riid == IID_IUnknown || riid == IID_ITrueCryptMainCom)

+ *ppvObject = this;

+ else

+ {

+ *ppvObject = NULL;

+ return E_NOINTERFACE;

+ }

+

+ AddRef ();

+ return S_OK;

+ }

+

+ virtual void STDMETHODCALLTYPE AnalyzeKernelMiniDump (LONG_PTR hwndDlg)

+ {

+ MainDlg = (HWND) hwndDlg;

+ ::AnalyzeKernelMiniDump ((HWND) hwndDlg);

+ }

+

+ virtual int STDMETHODCALLTYPE BackupVolumeHeader (LONG_PTR hwndDlg, BOOL bRequireConfirmation, BSTR lpszVolume)

+ {

+ USES_CONVERSION;

+ MainDlg = (HWND) hwndDlg;

+ return ::BackupVolumeHeader ((HWND) hwndDlg, bRequireConfirmation, CW2A (lpszVolume));

+ }

+

+ virtual int STDMETHODCALLTYPE RestoreVolumeHeader (LONG_PTR hwndDlg, BSTR lpszVolume)

+ {

+ USES_CONVERSION;

+ MainDlg = (HWND) hwndDlg;

+ return ::RestoreVolumeHeader ((HWND) hwndDlg, CW2A (lpszVolume));

+ }

+

+ virtual DWORD STDMETHODCALLTYPE CallDriver (DWORD ioctl, BSTR input, BSTR *output)

+ {

+ return BaseCom::CallDriver (ioctl, input, output);

+ }

+

+ virtual int STDMETHODCALLTYPE ChangePassword (BSTR volumePath, Password *oldPassword, Password *newPassword, int pkcs5, LONG_PTR hWnd)

+ {

+ USES_CONVERSION;

+ MainDlg = (HWND) hWnd;

+ return ::ChangePwd (CW2A (volumePath), oldPassword, newPassword, pkcs5, (HWND) hWnd);

+ }

+

+ virtual DWORD STDMETHODCALLTYPE CopyFile (BSTR sourceFile, BSTR destinationFile)

+ {

+ return BaseCom::CopyFile (sourceFile, destinationFile);

+ }

+

+ virtual DWORD STDMETHODCALLTYPE DeleteFile (BSTR file)

+ {

+ return BaseCom::DeleteFile (file);

+ }

+

+ virtual BOOL STDMETHODCALLTYPE IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly)

+ {

+ return BaseCom::IsPagingFileActive (checkNonWindowsPartitionsOnly);

+ }

+

+ virtual DWORD STDMETHODCALLTYPE ReadWriteFile (BOOL write, BOOL device, BSTR filePath, BSTR *bufferBstr, unsigned __int64 offset, unsigned __int32 size, DWORD *sizeDone)

+ {

+ return BaseCom::ReadWriteFile (write, device, filePath, bufferBstr, offset, size, sizeDone);

+ }

+

+ virtual DWORD STDMETHODCALLTYPE RegisterFilterDriver (BOOL registerDriver, int filterType)

+ {

+ return BaseCom::RegisterFilterDriver (registerDriver, filterType);

+ }

+

+ virtual DWORD STDMETHODCALLTYPE RegisterSystemFavoritesService (BOOL registerService)

+ {

+ return BaseCom::RegisterSystemFavoritesService (registerService);

+ }

+

+ virtual DWORD STDMETHODCALLTYPE SetDriverServiceStartType (DWORD startType)

+ {

+ return BaseCom::SetDriverServiceStartType (startType);

+ }

+

+ virtual DWORD STDMETHODCALLTYPE WriteLocalMachineRegistryDwordValue (BSTR keyPath, BSTR valueName, DWORD value)

+ {

+ return BaseCom::WriteLocalMachineRegistryDwordValue (keyPath, valueName, value);

+ }

+

+protected:

+ DWORD MessageThreadId;

+ LONG RefCount;

+};

+

+

+extern "C" BOOL ComServerMain ()

+{

+ SetProcessShutdownParameters (0x100, 0);

+

+ TrueCryptFactory<TrueCryptMainCom> factory (GetCurrentThreadId ());

+ DWORD cookie;

+

+ if (IsUacSupported ())

+ UacElevated = TRUE;

+

+ if (CoRegisterClassObject (CLSID_TrueCryptMainCom, (LPUNKNOWN) &factory,

+ CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie) != S_OK)

+ return FALSE;

+

+ MSG msg;

+ while (int r = GetMessage (&msg, NULL, 0, 0))

+ {

+ if (r == -1)

+ return FALSE;

+

+ TranslateMessage (&msg);

+ DispatchMessage (&msg);

+

+ if (msg.message == WM_APP

+ && ObjectCount < 1

+ && !factory.IsServerLocked ())

+ break;

+ }

+ CoRevokeClassObject (cookie);

+

+ return TRUE;

+}

+

+

+static BOOL ComGetInstance (HWND hWnd, ITrueCryptMainCom **tcServer)

+{

+ return ComGetInstanceBase (hWnd, CLSID_TrueCryptMainCom, IID_ITrueCryptMainCom, (void **) tcServer);

+}

+

+

+ITrueCryptMainCom *GetElevatedInstance (HWND parent)

+{

+ ITrueCryptMainCom *instance;

+

+ if (!ComGetInstance (parent, &instance))

+ throw UserAbort (SRC_POS);

+

+ return instance;

+}

+

+

+extern "C" void UacAnalyzeKernelMiniDump (HWND hwndDlg)

+{

+ CComPtr<ITrueCryptMainCom> tc;

+

+ CoInitialize (NULL);

+

+ if (ComGetInstance (hwndDlg, &tc))

+ {

+ WaitCursor();

+ tc->AnalyzeKernelMiniDump ((LONG_PTR) hwndDlg);

+ NormalCursor();

+ }

+

+ CoUninitialize ();

+}

+

+

+extern "C" int UacBackupVolumeHeader (HWND hwndDlg, BOOL bRequireConfirmation, char *lpszVolume)

+{

+ CComPtr<ITrueCryptMainCom> tc;

+ int r;

+

+ CoInitialize (NULL);

+

+ if (ComGetInstance (hwndDlg, &tc))

+ r = tc->BackupVolumeHeader ((LONG_PTR) hwndDlg, bRequireConfirmation, CComBSTR (lpszVolume));

+ else

+ r = -1;

+

+ CoUninitialize ();

+

+ return r;

+}

+

+

+extern "C" int UacRestoreVolumeHeader (HWND hwndDlg, char *lpszVolume)

+{

+ CComPtr<ITrueCryptMainCom> tc;

+ int r;

+

+ CoInitialize (NULL);

+

+ if (ComGetInstance (hwndDlg, &tc))

+ r = tc->RestoreVolumeHeader ((LONG_PTR) hwndDlg, CComBSTR (lpszVolume));

+ else

+ r = -1;

+

+ CoUninitialize ();

+

+ return r;

+}

+

+

+extern "C" int UacChangePwd (char *lpszVolume, Password *oldPassword, Password *newPassword, int pkcs5, HWND hwndDlg)

+{

+ CComPtr<ITrueCryptMainCom> tc;

+ int r;

+

+ if (ComGetInstance (hwndDlg, &tc))

+ {

+ WaitCursor ();

+ r = tc->ChangePassword (CComBSTR (lpszVolume), oldPassword, newPassword, pkcs5, (LONG_PTR) hwndDlg);

+ NormalCursor ();

+ }

+ else

+ r = -1;

+

+ return r;

+}

+/*

+ Copyright (c) 2007-2010 TrueCrypt Developers Association. All rights reserved.

+

+ Governed by the TrueCrypt License 3.0 the full text of which is contained in

+ the file License.txt included in TrueCrypt binary and source code distribution

+ packages.

+*/

+

+#ifndef TC_HEADER_MAIN_COM

+#define TC_HEADER_MAIN_COM

+

+#include <windows.h>

+

+#ifdef __cplusplus

+

+#include "MainCom_h.h"

+ITrueCryptMainCom *GetElevatedInstance (HWND parent);

+

+extern "C" {

+#endif

+

+BOOL ComServerMain ();

+void UacAnalyzeKernelMiniDump (HWND hwndDlg);

+int UacBackupVolumeHeader (HWND hwndDlg, BOOL bRequireConfirmation, char *lpszVolume);

+int UacRestoreVolumeHeader (HWND hwndDlg, char *lpszVolume);

+int UacChangePwd (char *lpszVolume, Password *oldPassword, Password *newPassword, int pkcs5, HWND hwndDlg);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif // TC_HEADER_MAIN_COM

+/*

+ Copyright (c) 2007-2010 TrueCrypt Developers Association. All rights reserved.

+

+ Governed by the TrueCrypt License 3.0 the full text of which is contained in

+ the file License.txt included in TrueCrypt binary and source code distribution

+ packages.

+*/

+

+import "wtypes.idl";

+import "..\Common\Password.h";

+

+[

+ uuid(1770F56C-7881-4591-A179-79B8001C7D42),

+ helpstring("TrueCrypt Main UAC Support Library"),

+ version(2.4) // Update ComSetup.cpp when changing version number

+]

+library TrueCryptMainCom

+{

+ [

+ uuid(252C9DE6-D4B9-4A59-8A10-9CA73217B3D0),

+ object,

+ oleautomation,

+ helpstring("TrueCrypt Main UAC Support Interface")

+ ]

+ interface ITrueCryptMainCom : IUnknown

+ {

+ void AnalyzeKernelMiniDump (LONG_PTR hwndDlg);

+ int BackupVolumeHeader (LONG_PTR hwndDlg, BOOL bRequireConfirmation, BSTR lpszVolume);

+ DWORD CallDriver (DWORD ioctl, BSTR input, BSTR *output);

+ int ChangePassword (BSTR volumePath, Password *oldPassword, Password *newPassword, int pkcs5, LONG_PTR hWnd);

+ DWORD CopyFile (BSTR sourceFile, BSTR destinationFile);

+ DWORD DeleteFile (BSTR file);

+ BOOL IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly);

+ DWORD ReadWriteFile (BOOL write, BOOL device, BSTR filePath, BSTR *bufferBstr, unsigned __int64 offset, unsigned __int32 size, DWORD *sizeDone);

+ DWORD RegisterFilterDriver (BOOL registerDriver, int filterType);

+ DWORD RegisterSystemFavoritesService (BOOL registerService);

+ int RestoreVolumeHeader (LONG_PTR hwndDlg, BSTR lpszVolume);

+ DWORD SetDriverServiceStartType (DWORD startType);

+ DWORD WriteLocalMachineRegistryDwordValue (BSTR keyPath, BSTR valueName, DWORD value);

+ };

+

+ [

+ uuid(CECBC0EE-78D9-41E6-BCF1-BC222BB224BA),

+ helpstring("TrueCrypt Main UAC Support Coclass")

+ ]

+ coclass TrueCryptMainCom

+ {

+ [default] interface ITrueCryptMainCom;

+ }

+}

+/*

+ Legal Notice: Some portions of the source code contained in this file were

+ derived from the source code of Encryption for the Masses 2.02a, which is

+ Copyright (c) 1998-2000 Paul Le Roux and which is governed by the 'License

+ Agreement for Encryption for the Masses'. Modifications and additions to

+ the original source code (contained in this file) and all other portions

+ of this file are Copyright (c) 2003-2012 TrueCrypt Developers Association

+ and are governed by the TrueCrypt License 3.0 the full text of which is

+ contained in the file License.txt included in TrueCrypt binary and source

+ code distribution packages. */

+

+#include "Tcdefs.h"

+

+#include <time.h>

+#include <math.h>

+#include <dbt.h>

+#include <fcntl.h>

+#include <io.h>

+#include <shlobj.h>

+#include <sys/stat.h>

+#include <windowsx.h>

+

+#include "Apidrvr.h"

+#include "BootEncryption.h"

+#include "Cmdline.h"

+#include "Crypto.h"

+#include "Dlgcode.h"

+#include "Combo.h"

+#include "Favorites.h"

+#include "Hotkeys.h"

+#include "Keyfiles.h"

+#include "Language.h"

+#include "MainCom.h"

+#include "Mount.h"

+#include "Pkcs5.h"

+#include "Random.h"

+#include "Registry.h"

+#include "Resource.h"

+#include "Password.h"

+#include "Xml.h"

+#include "../Boot/Windows/BootCommon.h"

+#include "../Common/Dictionary.h"

+#include "../Common/Common.h"

+#include "../Common/Resource.h"

+#include "../Common/SecurityToken.h"

+#include "../Platform/Finally.h"

+#include "../Platform/ForEach.h"

+

+using namespace TrueCrypt;

+

+enum timer_ids

+{

+ TIMER_ID_MAIN = 0xff,

+ TIMER_ID_KEYB_LAYOUT_GUARD

+};

+

+enum hidden_os_read_only_notif_mode

+{

+ TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_NONE = 0,

+ TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_COMPACT,

+ TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_DISABLED

+};

+

+#define TIMER_INTERVAL_MAIN 500

+#define TIMER_INTERVAL_KEYB_LAYOUT_GUARD 10

+

+BootEncryption *BootEncObj = NULL;

+BootEncryptionStatus BootEncStatus;

+BootEncryptionStatus RecentBootEncStatus;

+

+BOOL bExplore = FALSE; /* Display explorer window after mount */

+BOOL bBeep = FALSE; /* Donot beep after mount */

+char szFileName[TC_MAX_PATH+1]; /* Volume to mount */

+char szDriveLetter[3]; /* Drive Letter to mount */

+char commandLineDrive = 0;

+BOOL bCacheInDriver = FALSE; /* Cache any passwords we see */

+BOOL bCacheInDriverDefault = FALSE;

+BOOL bHistoryCmdLine = FALSE; /* History control is always disabled */

+BOOL bUseDifferentTrayIconIfVolMounted = TRUE;

+BOOL bCloseDismountedWindows=TRUE; /* Close all open explorer windows of dismounted volume */

+BOOL bWipeCacheOnExit = FALSE; /* Wipe password from chace on exit */

+BOOL bWipeCacheOnAutoDismount = TRUE;

+BOOL bEnableBkgTask = FALSE;

+BOOL bCloseBkgTaskWhenNoVolumes = FALSE;

+BOOL bDismountOnLogOff = TRUE;

+BOOL bDismountOnScreenSaver = TRUE;

+BOOL bDismountOnPowerSaving = FALSE;

+BOOL bForceAutoDismount = TRUE;

+BOOL bForceMount = FALSE; /* Mount volume even if host file/device already in use */

+BOOL bForceUnmount = FALSE; /* Unmount volume even if it cannot be locked */

+BOOL bWipe = FALSE; /* Wipe driver passwords */

+BOOL bAuto = FALSE; /* Do everything without user input */

+BOOL LogOn = FALSE;

+BOOL bAutoMountDevices = FALSE; /* Auto-mount devices */

+BOOL bAutoMountFavorites = FALSE;

+BOOL bPlaySoundOnSuccessfulHkDismount = TRUE;

+BOOL bDisplayBalloonOnSuccessfulHkDismount = TRUE;

+BOOL bHibernationPreventionNotified = FALSE; /* TRUE if the user has been notified that hibernation was prevented (system encryption) during the session. */

+BOOL bHiddenSysLeakProtNotifiedDuringSession = FALSE; /* TRUE if the user has been notified during the session that unencrypted filesystems and non-hidden TrueCrypt volumes are mounted as read-only under hidden OS. */

+BOOL CloseSecurityTokenSessionsAfterMount = FALSE;

+BOOL DisableSystemCrashDetection = FALSE;

+BOOL SystemCrashDetected = FALSE;

+

+BOOL Quit = FALSE; /* Exit after processing command line */

+BOOL ComServerMode = FALSE;

+BOOL ServiceMode = FALSE;

+BOOL UsePreferences = TRUE;

+

+int HiddenSysLeakProtectionNotificationStatus = TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_NONE;

+int MaxVolumeIdleTime = -120;

+int nCurrentShowType = 0; /* current display mode, mount, unmount etc */

+int nSelectedDriveIndex = -1; /* Item number of selected drive */

+

+int cmdUnmountDrive = 0; /* Volume drive letter to unmount (-1 = all) */

+Password VolumePassword; /* Password used for mounting volumes */

+Password CmdVolumePassword; /* Password passed from command line */

+BOOL CmdVolumePasswordValid = FALSE;

+MountOptions CmdMountOptions;

+BOOL CmdMountOptionsValid = FALSE;

+MountOptions mountOptions;

+MountOptions defaultMountOptions;

+KeyFile *FirstCmdKeyFile;

+

+HBITMAP hbmLogoBitmapRescaled = NULL;

+char OrigKeyboardLayout [8+1] = "00000409";

+BOOL bKeyboardLayoutChanged = FALSE; /* TRUE if the keyboard layout was changed to the standard US keyboard layout (from any other layout). */

+BOOL bKeybLayoutAltKeyWarningShown = FALSE; /* TRUE if the user has been informed that it is not possible to type characters by pressing keys while the right Alt key is held down. */

+

+static KeyFilesDlgParam hidVolProtKeyFilesParam;

+

+static MOUNT_LIST_STRUCT LastKnownMountList;

+VOLUME_NOTIFICATIONS_LIST VolumeNotificationsList;

+static DWORD LastKnownLogicalDrives;

+

+static HANDLE TaskBarIconMutex = NULL;

+static BOOL MainWindowHidden = FALSE;

+static int pwdChangeDlgMode = PCDM_CHANGE_PASSWORD;

+static int bSysEncPwdChangeDlgMode = FALSE;

+static int bPrebootPasswordDlgMode = FALSE;

+static int NoCmdLineArgs;

+static BOOL CmdLineVolumeSpecified;

+static int LastDriveListVolumeColumnWidth;

+

+static void localcleanup (void)

+{

+ // Wipe command line

+ char *c = GetCommandLineA ();

+ wchar_t *wc = GetCommandLineW ();

+ burn(c, strlen (c));

+ burn(wc, wcslen (wc) * sizeof (wchar_t));

+

+ /* Delete buffered bitmaps (if any) */

+ if (hbmLogoBitmapRescaled != NULL)

+ {

+ DeleteObject ((HGDIOBJ) hbmLogoBitmapRescaled);

+ hbmLogoBitmapRescaled = NULL;

+ }

+

+ /* These items should have already been cleared by the functions that used them, but we're going to

+ clear them for extra security. */

+ burn (&VolumePassword, sizeof (VolumePassword));

+ burn (&CmdVolumePassword, sizeof (CmdVolumePassword));

+ burn (&mountOptions, sizeof (mountOptions));

+ burn (&defaultMountOptions, sizeof (defaultMountOptions));

+ burn (&szFileName, sizeof(szFileName));

+

+ /* Cleanup common code resources */

+ cleanup ();

+

+ if (BootEncObj != NULL)

+ {

+ delete BootEncObj;

+ BootEncObj = NULL;

+ }

+

+ RandStop (TRUE);

+}

+

+void RefreshMainDlg (HWND hwndDlg)

+{

+ int drive = (char) (HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))));

+

+ MoveEditToCombo (GetDlgItem (hwndDlg, IDC_VOLUME), bHistory);

+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), drive);

+ EnableDisableButtons (hwndDlg);

+}

+

+void EndMainDlg (HWND hwndDlg)

+{

+ MoveEditToCombo (GetDlgItem (hwndDlg, IDC_VOLUME), bHistory);

+

+ if (UsePreferences)

+ SaveSettings (hwndDlg);

+

+ if (bWipeCacheOnExit)

+ {

+ DWORD dwResult;

+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);

+ }

+

+ if (!bHistory)

+ {

+ SetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), "");

+ ClearHistory (GetDlgItem (hwndDlg, IDC_VOLUME));

+ }

+

+ if (TaskBarIconMutex != NULL)

+ {

+ MainWindowHidden = TRUE;

+ ShowWindow (hwndDlg, SW_HIDE);

+ }

+ else

+ {

+ KillTimer (hwndDlg, TIMER_ID_MAIN);

+ TaskBarIconRemove (hwndDlg);

+ EndDialog (hwndDlg, 0);

+ }

+}

+

+static void InitMainDialog (HWND hwndDlg)

+{

+ MENUITEMINFOW info;

+ char *popupTexts[] = {"MENU_VOLUMES", "MENU_SYSTEM_ENCRYPTION", "MENU_FAVORITES", "MENU_TOOLS", "MENU_SETTINGS", "MENU_HELP", "MENU_WEBSITE", 0};

+ wchar_t *str;

+ int i;

+

+ /* Call the common dialog init code */

+ InitDialog (hwndDlg);

+ LocalizeDialog (hwndDlg, NULL);

+

+ SetWindowLongPtr (hwndDlg, DWLP_USER, (LONG_PTR) (IsAdmin() ? TC_MAIN_WINDOW_FLAG_ADMIN_PRIVILEGES : 0));

+

+ DragAcceptFiles (hwndDlg, TRUE);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_VOLUME), CB_LIMITTEXT, TC_MAX_PATH, 0);

+ SetWindowTextW (hwndDlg, (IsAdmin() && !IsBuiltInAdmin() && IsUacSupported() && !IsNonInstallMode()) ? (wstring (lpszTitle) + L" [" + GetString ("ADMINISTRATOR") + L"]").c_str() : lpszTitle);

+

+ // Help file name

+ InitHelpFileName();

+

+ // Localize menu strings

+ for (i = 40001; str = (wchar_t *)GetDictionaryValueByInt (i); i++)

+ {

+ info.cbSize = sizeof (info);

+ info.fMask = MIIM_TYPE;

+ info.fType = MFT_STRING;

+ info.dwTypeData = str;

+ info.cch = wcslen (str);

+

+ SetMenuItemInfoW (GetMenu (hwndDlg), i, FALSE, &info);

+ }

+

+ for (i = 0; popupTexts[i] != 0; i++)

+ {

+ str = GetString (popupTexts[i]);

+

+ info.cbSize = sizeof (info);

+ info.fMask = MIIM_TYPE;

+

+ if (strcmp (popupTexts[i], "MENU_WEBSITE") == 0)

+ info.fType = MFT_STRING | MFT_RIGHTJUSTIFY;

+ else

+ info.fType = MFT_STRING;

+

+ if (strcmp (popupTexts[i], "MENU_FAVORITES") == 0)

+ FavoriteVolumesMenu = GetSubMenu (GetMenu (hwndDlg), i);

+

+ info.dwTypeData = str;

+ info.cch = wcslen (str);

+

+ SetMenuItemInfoW (GetMenu (hwndDlg), i, TRUE, &info);

+ }

+

+ try

+ {

+ LoadFavoriteVolumes();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ }

+

+ // Resize the logo bitmap if the user has a non-default DPI

+ if (ScreenDPI != USER_DEFAULT_SCREEN_DPI

+ && hbmLogoBitmapRescaled == NULL) // If not re-called (e.g. after language pack change)

+ {

+ hbmLogoBitmapRescaled = RenderBitmap (MAKEINTRESOURCE (IDB_LOGO_288DPI),

+ GetDlgItem (hwndDlg, IDC_LOGO),

+ 0, 0, 0, 0, FALSE, TRUE);

+ }

+

+ BuildTree (GetDlgItem (hwndDlg, IDC_DRIVELIST));

+

+ if (*szDriveLetter != 0)

+ {

+ SelectItem (GetDlgItem (hwndDlg, IDC_DRIVELIST), *szDriveLetter);

+

+ if(nSelectedDriveIndex > SendMessage (GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_GETITEMCOUNT, 0, 0)/2)

+ SendMessage(GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_SCROLL, 0, 10000);

+ }

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_NO_HISTORY), BM_SETCHECK, bHistory ? BST_UNCHECKED : BST_CHECKED, 0);

+ EnableDisableButtons (hwndDlg);

+}

+

+void EnableDisableButtons (HWND hwndDlg)

+{

+ HWND hOKButton = GetDlgItem (hwndDlg, IDOK);

+ WORD x;

+

+ x = LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST)));

+

+ EnableMenuItem (GetMenu (hwndDlg), IDM_MOUNT_VOLUME, MF_ENABLED);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_MOUNT_VOLUME_OPTIONS, MF_ENABLED);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_BACKUP_VOL_HEADER, MF_ENABLED);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_RESTORE_VOL_HEADER, MF_ENABLED);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_CHANGE_PASSWORD, MF_ENABLED);

+ EnableWindow (hOKButton, TRUE);

+

+ switch (x)

+ {

+ case TC_MLIST_ITEM_NONSYS_VOL:

+ {

+ SetWindowTextW (hOKButton, GetString ("UNMOUNT_BUTTON"));

+ EnableWindow (hOKButton, TRUE);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_UNMOUNT_VOLUME, MF_ENABLED);

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), TRUE);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_VOLUME_PROPERTIES, MF_ENABLED);

+ }

+ break;

+

+ case TC_MLIST_ITEM_SYS_PARTITION:

+ case TC_MLIST_ITEM_SYS_DRIVE:

+ EnableWindow (hOKButton, FALSE);

+ SetWindowTextW (hOKButton, GetString ("MOUNT_BUTTON"));

+ EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), TRUE);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_UNMOUNT_VOLUME, MF_GRAYED);

+ break;

+

+ case TC_MLIST_ITEM_FREE:

+ default:

+ SetWindowTextW (hOKButton, GetString ("MOUNT_BUTTON"));

+ EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), FALSE);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_VOLUME_PROPERTIES, MF_GRAYED);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_UNMOUNT_VOLUME, MF_GRAYED);

+ }

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_WIPE_CACHE), !IsPasswordCacheEmpty());

+ EnableMenuItem (GetMenu (hwndDlg), IDM_WIPE_CACHE, IsPasswordCacheEmpty() ? MF_GRAYED:MF_ENABLED);

+ EnableMenuItem (GetMenu (hwndDlg), IDM_CLEAR_HISTORY, IsComboEmpty (GetDlgItem (hwndDlg, IDC_VOLUME)) ? MF_GRAYED:MF_ENABLED);

+}

+

+BOOL VolumeSelected (HWND hwndDlg)

+{

+ return (GetWindowTextLength (GetDlgItem (hwndDlg, IDC_VOLUME)) > 0);

+}

+

+/* Returns TRUE if the last partition/drive selected via the Select Device dialog box was the system

+partition/drive and if it is encrypted.

+ WARNING: This function is very fast but not always reliable (for example, if the user manually types

+ a device path before Select Device is invoked during the session; after the Select Device dialog

+ has been invoked at least once, the correct system device paths are cached). Therefore, it must NOT

+ be used before performing any dangerous operations (such as header backup restore or formatting a

+ supposedly non-system device) -- instead use IsSystemDevicePath(path, hwndDlg, TRUE) for such

+ purposes. This function can be used only for preliminary GUI checks requiring very fast responses. */

+BOOL ActiveSysEncDeviceSelected (void)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+

+ if (BootEncStatus.DriveEncrypted)

+ {

+ int retCode = 0;

+

+ GetWindowText (GetDlgItem (MainDlg, IDC_VOLUME), szFileName, sizeof (szFileName));

+

+ retCode = IsSystemDevicePath (szFileName, MainDlg, FALSE);

+

+ return (WholeSysDriveEncryption(FALSE) ? (retCode == 2 || retCode == 1) : (retCode == 1));

+ }

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ return FALSE;

+}

+

+void LoadSettings (HWND hwndDlg)

+{

+ EnableHwEncryption ((ReadDriverConfigurationFlags() & TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION) ? FALSE : TRUE);

+

+ WipeAlgorithmId savedWipeAlgorithm = TC_WIPE_NONE;

+

+ LoadSysEncSettings (hwndDlg);

+

+ if (LoadNonSysInPlaceEncSettings (&savedWipeAlgorithm) != 0)

+ bInPlaceEncNonSysPending = TRUE;

+

+ // If the config file has already been loaded during this session

+ if (ConfigBuffer != NULL)

+ {

+ free (ConfigBuffer);

+ ConfigBuffer = NULL;

+ }

+

+ // Options

+ bExplore = ConfigReadInt ("OpenExplorerWindowAfterMount", FALSE);

+ bUseDifferentTrayIconIfVolMounted = ConfigReadInt ("UseDifferentTrayIconIfVolumesMounted", TRUE);

+

+ bHistory = ConfigReadInt ("SaveVolumeHistory", FALSE);

+

+ bCacheInDriverDefault = bCacheInDriver = ConfigReadInt ("CachePasswords", FALSE);

+ bWipeCacheOnExit = ConfigReadInt ("WipePasswordCacheOnExit", FALSE);

+ bWipeCacheOnAutoDismount = ConfigReadInt ("WipeCacheOnAutoDismount", TRUE);

+

+ bStartOnLogon = ConfigReadInt ("StartOnLogon", FALSE);

+ bMountDevicesOnLogon = ConfigReadInt ("MountDevicesOnLogon", FALSE);

+ bMountFavoritesOnLogon = ConfigReadInt ("MountFavoritesOnLogon", FALSE);

+

+ bEnableBkgTask = ConfigReadInt ("EnableBackgroundTask", TRUE);

+ bCloseBkgTaskWhenNoVolumes = ConfigReadInt ("CloseBackgroundTaskOnNoVolumes", FALSE);

+

+ bDismountOnLogOff = ConfigReadInt ("DismountOnLogOff", !(IsServerOS() && IsAdmin()));

+ bDismountOnPowerSaving = ConfigReadInt ("DismountOnPowerSaving", FALSE);

+ bDismountOnScreenSaver = ConfigReadInt ("DismountOnScreenSaver", FALSE);

+ bForceAutoDismount = ConfigReadInt ("ForceAutoDismount", TRUE);

+ MaxVolumeIdleTime = ConfigReadInt ("MaxVolumeIdleTime", -60);

+

+ HiddenSectorDetectionStatus = ConfigReadInt ("HiddenSectorDetectionStatus", 0);

+

+ defaultKeyFilesParam.EnableKeyFiles = ConfigReadInt ("UseKeyfiles", FALSE);

+

+ bPreserveTimestamp = defaultMountOptions.PreserveTimestamp = ConfigReadInt ("PreserveTimestamps", TRUE);

+ defaultMountOptions.Removable = ConfigReadInt ("MountVolumesRemovable", FALSE);

+ defaultMountOptions.ReadOnly = ConfigReadInt ("MountVolumesReadOnly", FALSE);

+ defaultMountOptions.ProtectHiddenVolume = FALSE;

+ defaultMountOptions.PartitionInInactiveSysEncScope = FALSE;

+ defaultMountOptions.RecoveryMode = FALSE;

+ defaultMountOptions.UseBackupHeader = FALSE;

+

+ mountOptions = defaultMountOptions;

+

+ CloseSecurityTokenSessionsAfterMount = ConfigReadInt ("CloseSecurityTokenSessionsAfterMount", 0);

+ DisableSystemCrashDetection = ConfigReadInt ("DisableSystemCrashDetection", FALSE);

+

+ if (IsHiddenOSRunning())

+ HiddenSysLeakProtectionNotificationStatus = ConfigReadInt ("HiddenSystemLeakProtNotifStatus", TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_NONE);

+

+ // Drive letter - command line arg overrides registry

+ if (szDriveLetter[0] == 0)

+ ConfigReadString ("LastSelectedDrive", "", szDriveLetter, sizeof (szDriveLetter));

+

+ ConfigReadString ("SecurityTokenLibrary", "", SecurityTokenLibraryPath, sizeof (SecurityTokenLibraryPath) - 1);

+ if (SecurityTokenLibraryPath[0])

+ InitSecurityTokenLibrary();

+

+ // Hotkeys

+ bPlaySoundOnSuccessfulHkDismount = ConfigReadInt ("PlaySoundOnHotkeyMountDismount", TRUE);

+ bDisplayBalloonOnSuccessfulHkDismount = ConfigReadInt ("DisplayMsgBoxOnHotkeyDismount", TRUE);

+ Hotkeys [HK_AUTOMOUNT_DEVICES].vKeyModifiers = ConfigReadInt ("HotkeyModAutoMountDevices", 0);

+ Hotkeys [HK_AUTOMOUNT_DEVICES].vKeyCode = ConfigReadInt ("HotkeyCodeAutoMountDevices", 0);

+ Hotkeys [HK_DISMOUNT_ALL].vKeyModifiers = ConfigReadInt ("HotkeyModDismountAll", 0);

+ Hotkeys [HK_DISMOUNT_ALL].vKeyCode = ConfigReadInt ("HotkeyCodeDismountAll", 0);

+ Hotkeys [HK_WIPE_CACHE].vKeyModifiers = ConfigReadInt ("HotkeyModWipeCache", 0);

+ Hotkeys [HK_WIPE_CACHE].vKeyCode = ConfigReadInt ("HotkeyCodeWipeCache", 0);

+ Hotkeys [HK_DISMOUNT_ALL_AND_WIPE].vKeyModifiers = ConfigReadInt ("HotkeyModDismountAllWipe", 0);

+ Hotkeys [HK_DISMOUNT_ALL_AND_WIPE].vKeyCode = ConfigReadInt ("HotkeyCodeDismountAllWipe", 0);

+ Hotkeys [HK_FORCE_DISMOUNT_ALL_AND_WIPE].vKeyModifiers = ConfigReadInt ("HotkeyModForceDismountAllWipe", 0);

+ Hotkeys [HK_FORCE_DISMOUNT_ALL_AND_WIPE].vKeyCode = ConfigReadInt ("HotkeyCodeForceDismountAllWipe", 0);

+ Hotkeys [HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT].vKeyModifiers = ConfigReadInt ("HotkeyModForceDismountAllWipeExit", 0);

+ Hotkeys [HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT].vKeyCode = ConfigReadInt ("HotkeyCodeForceDismountAllWipeExit", 0);

+ Hotkeys [HK_MOUNT_FAVORITE_VOLUMES].vKeyModifiers = ConfigReadInt ("HotkeyModMountFavoriteVolumes", 0);

+ Hotkeys [HK_MOUNT_FAVORITE_VOLUMES].vKeyCode = ConfigReadInt ("HotkeyCodeMountFavoriteVolumes", 0);

+ Hotkeys [HK_SHOW_HIDE_MAIN_WINDOW].vKeyModifiers = ConfigReadInt ("HotkeyModShowHideMainWindow", 0);

+ Hotkeys [HK_SHOW_HIDE_MAIN_WINDOW].vKeyCode = ConfigReadInt ("HotkeyCodeShowHideMainWindow", 0);

+ Hotkeys [HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyModifiers = ConfigReadInt ("HotkeyModCloseSecurityTokenSessions", 0);

+ Hotkeys [HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyCode = ConfigReadInt ("HotkeyCodeCloseSecurityTokenSessions", 0);

+

+ // History

+ if (bHistoryCmdLine != TRUE)

+ {

+ LoadCombo (GetDlgItem (hwndDlg, IDC_VOLUME));

+ if (CmdLineVolumeSpecified)

+ SetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);

+ }

+}

+

+void SaveSettings (HWND hwndDlg)

+{

+ WaitCursor ();

+

+ char szTmp[32] = {0};

+ LPARAM lLetter;

+

+ // Options

+ ConfigWriteBegin ();

+

+ ConfigWriteInt ("OpenExplorerWindowAfterMount", bExplore);

+ ConfigWriteInt ("UseDifferentTrayIconIfVolumesMounted", bUseDifferentTrayIconIfVolMounted);

+ ConfigWriteInt ("SaveVolumeHistory", !IsButtonChecked (GetDlgItem (hwndDlg, IDC_NO_HISTORY)));

+

+ ConfigWriteInt ("CachePasswords", bCacheInDriverDefault);

+ ConfigWriteInt ("WipePasswordCacheOnExit", bWipeCacheOnExit);

+ ConfigWriteInt ("WipeCacheOnAutoDismount", bWipeCacheOnAutoDismount);

+

+ ConfigWriteInt ("StartOnLogon", bStartOnLogon);

+ ConfigWriteInt ("MountDevicesOnLogon", bMountDevicesOnLogon);

+ ConfigWriteInt ("MountFavoritesOnLogon", bMountFavoritesOnLogon);

+

+ ConfigWriteInt ("MountVolumesReadOnly", defaultMountOptions.ReadOnly);

+ ConfigWriteInt ("MountVolumesRemovable", defaultMountOptions.Removable);

+ ConfigWriteInt ("PreserveTimestamps", defaultMountOptions.PreserveTimestamp);

+

+ ConfigWriteInt ("EnableBackgroundTask", bEnableBkgTask);

+ ConfigWriteInt ("CloseBackgroundTaskOnNoVolumes", bCloseBkgTaskWhenNoVolumes);

+

+ ConfigWriteInt ("DismountOnLogOff", bDismountOnLogOff);

+ ConfigWriteInt ("DismountOnPowerSaving", bDismountOnPowerSaving);

+ ConfigWriteInt ("DismountOnScreenSaver", bDismountOnScreenSaver);

+ ConfigWriteInt ("ForceAutoDismount", bForceAutoDismount);

+ ConfigWriteInt ("MaxVolumeIdleTime", MaxVolumeIdleTime);

+

+ ConfigWriteInt ("HiddenSectorDetectionStatus", HiddenSectorDetectionStatus);

+

+ ConfigWriteInt ("UseKeyfiles", defaultKeyFilesParam.EnableKeyFiles);

+

+ if (IsHiddenOSRunning())

+ ConfigWriteInt ("HiddenSystemLeakProtNotifStatus", HiddenSysLeakProtectionNotificationStatus);

+

+ // Drive Letter

+ lLetter = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));

+ if (LOWORD (lLetter) != 0xffff)

+ sprintf (szTmp, "%c:", (char) HIWORD (lLetter));

+ ConfigWriteString ("LastSelectedDrive", szTmp);

+

+ ConfigWriteInt ("CloseSecurityTokenSessionsAfterMount", CloseSecurityTokenSessionsAfterMount);

+ ConfigWriteInt ("DisableSystemCrashDetection", DisableSystemCrashDetection);

+

+ // Hotkeys

+ ConfigWriteInt ("HotkeyModAutoMountDevices", Hotkeys[HK_AUTOMOUNT_DEVICES].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeAutoMountDevices", Hotkeys[HK_AUTOMOUNT_DEVICES].vKeyCode);

+ ConfigWriteInt ("HotkeyModDismountAll", Hotkeys[HK_DISMOUNT_ALL].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeDismountAll", Hotkeys[HK_DISMOUNT_ALL].vKeyCode);

+ ConfigWriteInt ("HotkeyModWipeCache", Hotkeys[HK_WIPE_CACHE].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeWipeCache", Hotkeys[HK_WIPE_CACHE].vKeyCode);

+ ConfigWriteInt ("HotkeyModDismountAllWipe", Hotkeys[HK_DISMOUNT_ALL_AND_WIPE].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeDismountAllWipe", Hotkeys[HK_DISMOUNT_ALL_AND_WIPE].vKeyCode);

+ ConfigWriteInt ("HotkeyModForceDismountAllWipe", Hotkeys[HK_FORCE_DISMOUNT_ALL_AND_WIPE].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeForceDismountAllWipe", Hotkeys[HK_FORCE_DISMOUNT_ALL_AND_WIPE].vKeyCode);

+ ConfigWriteInt ("HotkeyModForceDismountAllWipeExit", Hotkeys[HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeForceDismountAllWipeExit", Hotkeys[HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT].vKeyCode);

+ ConfigWriteInt ("HotkeyModMountFavoriteVolumes", Hotkeys[HK_MOUNT_FAVORITE_VOLUMES].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeMountFavoriteVolumes", Hotkeys[HK_MOUNT_FAVORITE_VOLUMES].vKeyCode);

+ ConfigWriteInt ("HotkeyModShowHideMainWindow", Hotkeys[HK_SHOW_HIDE_MAIN_WINDOW].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeShowHideMainWindow", Hotkeys[HK_SHOW_HIDE_MAIN_WINDOW].vKeyCode);

+ ConfigWriteInt ("HotkeyModCloseSecurityTokenSessions", Hotkeys[HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyModifiers);

+ ConfigWriteInt ("HotkeyCodeCloseSecurityTokenSessions", Hotkeys[HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyCode);

+ ConfigWriteInt ("PlaySoundOnHotkeyMountDismount", bPlaySoundOnSuccessfulHkDismount);

+ ConfigWriteInt ("DisplayMsgBoxOnHotkeyDismount", bDisplayBalloonOnSuccessfulHkDismount);

+

+ // Language

+ if (GetPreferredLangId () != NULL)

+ ConfigWriteString ("Language", GetPreferredLangId ());

+

+ // PKCS#11 Library Path

+ ConfigWriteString ("SecurityTokenLibrary", SecurityTokenLibraryPath[0] ? SecurityTokenLibraryPath : "");

+

+ ConfigWriteEnd ();

+

+ // History

+ DumpCombo (GetDlgItem (hwndDlg, IDC_VOLUME), IsButtonChecked (GetDlgItem (hwndDlg, IDC_NO_HISTORY)));

+

+ NormalCursor ();

+}

+

+// Returns TRUE if system encryption or decryption had been or is in progress and has not been completed

+static BOOL SysEncryptionOrDecryptionRequired (void)

+{

+ /* If you update this function, revise SysEncryptionOrDecryptionRequired() in Tcformat.c as well. */

+

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ return (SystemEncryptionStatus == SYSENC_STATUS_ENCRYPTING

+ || SystemEncryptionStatus == SYSENC_STATUS_DECRYPTING

+ ||

+ (

+ BootEncStatus.DriveMounted

+ &&

+ (

+ BootEncStatus.ConfiguredEncryptedAreaStart != BootEncStatus.EncryptedAreaStart

+ || BootEncStatus.ConfiguredEncryptedAreaEnd != BootEncStatus.EncryptedAreaEnd

+ )

+ )

+ );

+}

+

+// Returns TRUE if the system partition/drive is completely encrypted

+static BOOL SysDriveOrPartitionFullyEncrypted (BOOL bSilent)

+{

+ /* If you update this function, revise SysDriveOrPartitionFullyEncrypted() in Tcformat.c as well. */

+

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ if (!bSilent)

+ e.Show (MainDlg);

+ }

+

+ return (!BootEncStatus.SetupInProgress

+ && BootEncStatus.ConfiguredEncryptedAreaEnd != 0

+ && BootEncStatus.ConfiguredEncryptedAreaEnd != -1

+ && BootEncStatus.ConfiguredEncryptedAreaStart == BootEncStatus.EncryptedAreaStart

+ && BootEncStatus.ConfiguredEncryptedAreaEnd == BootEncStatus.EncryptedAreaEnd);

+}

+

+// Returns TRUE if the system partition/drive is being filtered by the TrueCrypt driver and the key data

+// was successfully decrypted (the device is fully ready to be encrypted or decrypted). Note that this

+// function does not examine whether the system device is encrypted or not (or to what extent).

+static BOOL SysEncDeviceActive (BOOL bSilent)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ if (!bSilent)

+ e.Show (MainDlg);

+

+ return FALSE;

+ }

+

+ return (BootEncStatus.DriveMounted);

+}

+

+// Returns TRUE if the entire system drive (as opposed to the system partition only) is (or is to be) encrypted

+BOOL WholeSysDriveEncryption (BOOL bSilent)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+

+ return (BootEncStatus.ConfiguredEncryptedAreaStart == TC_BOOT_LOADER_AREA_SIZE

+ && BootEncStatus.ConfiguredEncryptedAreaEnd >= BootEncStatus.BootDriveLength.QuadPart - 1);

+ }

+ catch (Exception &e)

+ {

+ if (!bSilent)

+ e.Show (MainDlg);

+

+ return FALSE;

+ }

+}

+

+// Returns the size of the system drive/partition (if encrypted) in bytes

+unsigned __int64 GetSysEncDeviceSize (BOOL bSilent)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ if (!bSilent)

+ e.Show (MainDlg);

+ }

+

+ return (BootEncStatus.ConfiguredEncryptedAreaEnd - BootEncStatus.ConfiguredEncryptedAreaStart + 1);

+}

+

+// Returns the current size of the encrypted area of the system drive/partition in bytes

+unsigned __int64 GetSysEncDeviceEncryptedPartSize (BOOL bSilent)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ if (!bSilent)

+ e.Show (MainDlg);

+ }

+

+ return (BootEncStatus.EncryptedAreaEnd - BootEncStatus.EncryptedAreaStart + 1);

+}

+

+

+static void PopulateSysEncContextMenu (HMENU popup, BOOL bToolsOnly)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ if (!bToolsOnly && !IsHiddenOSRunning())

+ {

+ if (SysEncryptionOrDecryptionRequired ())

+ {

+ if (!BootEncStatus.SetupInProgress)

+ AppendMenuW (popup, MF_STRING, IDM_SYSENC_RESUME, GetString ("IDM_SYSENC_RESUME"));

+

+ if (SystemEncryptionStatus != SYSENC_STATUS_DECRYPTING)

+ AppendMenuW (popup, MF_STRING, IDM_PERMANENTLY_DECRYPT_SYS, GetString ("PERMANENTLY_DECRYPT"));

+

+ AppendMenuW (popup, MF_STRING, IDM_ENCRYPT_SYSTEM_DEVICE, GetString ("ENCRYPT"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ }

+ }

+

+ AppendMenuW (popup, MF_STRING, IDM_CHANGE_SYS_PASSWORD, GetString ("IDM_CHANGE_SYS_PASSWORD"));

+ AppendMenuW (popup, MF_STRING, IDM_CHANGE_SYS_HEADER_KEY_DERIV_ALGO, GetString ("IDM_CHANGE_SYS_HEADER_KEY_DERIV_ALGO"));

+

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDM_SYS_ENC_SETTINGS, GetString ("IDM_SYS_ENC_SETTINGS"));

+

+ if (!IsHiddenOSRunning())

+ {

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDM_CREATE_RESCUE_DISK, GetString ("IDM_CREATE_RESCUE_DISK"));

+ AppendMenuW (popup, MF_STRING, IDM_VERIFY_RESCUE_DISK, GetString ("IDM_VERIFY_RESCUE_DISK"));

+ }

+

+ if (!bToolsOnly)

+ {

+ if (SysDriveOrPartitionFullyEncrypted (FALSE) && !IsHiddenOSRunning())

+ {

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDM_PERMANENTLY_DECRYPT_SYS, GetString ("PERMANENTLY_DECRYPT"));

+ }

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDM_VOLUME_PROPERTIES, GetString ("IDPM_PROPERTIES"));

+ }

+}

+

+

+// WARNING: This function may take a long time to complete. To prevent data corruption, it MUST be called before

+// mounting a partition (as a regular volume) that is within key scope of system encryption.

+// Returns TRUE if the partition can be mounted as a partition within key scope of inactive system encryption.

+// If devicePath is empty, the currently selected partition in the GUI is checked.

+BOOL CheckSysEncMountWithoutPBA (const char *devicePath, BOOL quiet)

+{

+ BOOL tmpbDevice;

+ char szDevicePath [TC_MAX_PATH+1];

+ char szDiskFile [TC_MAX_PATH+1];

+

+ if (strlen (devicePath) < 2)

+ {

+ GetWindowText (GetDlgItem (MainDlg, IDC_VOLUME), szDevicePath, sizeof (szDevicePath));

+ CreateFullVolumePath (szDiskFile, szDevicePath, &tmpbDevice);

+

+ if (!tmpbDevice)

+ {

+ if (!quiet)

+ Warning ("NO_SYSENC_PARTITION_SELECTED");

+

+ return FALSE;

+ }

+

+ if (LOWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST))) != TC_MLIST_ITEM_FREE)

+ {

+ if (!quiet)

+ Warning ("SELECT_FREE_DRIVE");

+

+ return FALSE;

+ }

+ }

+ else

+ strncpy (szDevicePath, devicePath, sizeof (szDevicePath));

+

+ char *partionPortion = strrchr (szDevicePath, '\\');

+

+ if (!partionPortion

+ || !_stricmp (partionPortion, "\\Partition0"))

+ {

+ // Only partitions are supported (not whole drives)

+ if (!quiet)

+ Warning ("NO_SYSENC_PARTITION_SELECTED");

+

+ return FALSE;

+ }

+

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+

+ if (BootEncStatus.DriveMounted)

+ {

+ int retCode = 0;

+ int driveNo;

+ char parentDrivePath [TC_MAX_PATH+1];

+

+ if (sscanf (szDevicePath, "\\Device\\Harddisk%d\\Partition", &driveNo) != 1)

+ {

+ if (!quiet)

+ Error ("INVALID_PATH");

+

+ return FALSE;

+ }

+

+ _snprintf (parentDrivePath,

+ sizeof (parentDrivePath),

+ "\\Device\\Harddisk%d\\Partition0",

+ driveNo);

+

+ WaitCursor ();

+

+ // This is critical (re-mounting a mounted system volume as a normal volume could cause data corruption)

+ // so we force the slower but reliable method

+ retCode = IsSystemDevicePath (parentDrivePath, MainDlg, TRUE);

+

+ NormalCursor();

+

+ if (retCode != 2)

+ return TRUE;

+ else

+ {

+ // The partition is located on active system drive

+

+ if (!quiet)

+ Warning ("MOUNT_WITHOUT_PBA_VOL_ON_ACTIVE_SYSENC_DRIVE");

+

+ return FALSE;

+ }

+ }

+ else

+ return TRUE;

+ }

+ catch (Exception &e)

+ {

+ NormalCursor();

+ e.Show (MainDlg);

+ }

+

+ return FALSE;

+}

+

+

+// Returns TRUE if the host drive of the specified partition contains a portion of the TrueCrypt Boot Loader

+// and if the drive is not within key scope of active system encryption (e.g. the system drive of the running OS).

+// If bPrebootPasswordDlgMode is TRUE, this function returns FALSE (because the check would be redundant).

+BOOL TCBootLoaderOnInactiveSysEncDrive (void)

+{

+ try

+ {

+ int driveNo;

+ char szDevicePath [TC_MAX_PATH+1];

+ char parentDrivePath [TC_MAX_PATH+1];

+

+ if (bPrebootPasswordDlgMode)

+ return FALSE;

+

+ GetWindowText (GetDlgItem (MainDlg, IDC_VOLUME), szDevicePath, sizeof (szDevicePath));

+

+ if (sscanf (szDevicePath, "\\Device\\Harddisk%d\\Partition", &driveNo) != 1)

+ return FALSE;

+

+ _snprintf (parentDrivePath,

+ sizeof (parentDrivePath),

+ "\\Device\\Harddisk%d\\Partition0",

+ driveNo);

+

+ BootEncStatus = BootEncObj->GetStatus();

+

+ if (BootEncStatus.DriveMounted

+ && IsSystemDevicePath (parentDrivePath, MainDlg, FALSE) == 2)

+ {

+ // The partition is within key scope of active system encryption

+ return FALSE;

+ }

+

+ return ((BOOL) BootEncObj->IsBootLoaderOnDrive (parentDrivePath));

+ }

+ catch (...)

+ {

+ return FALSE;

+ }

+

+}

+

+

+BOOL SelectItem (HWND hTree, char nLetter)

+{

+ if (nLetter == 0)

+ {

+ // The caller specified an invalid drive letter (typically because it is unknown).

+ // Find out which drive letter is currently selected in the list and use it.

+ nLetter = (char) (HIWORD (GetSelectedLong (hTree)));

+ }

+

+ int i;

+ LVITEM item;

+

+ for (i = 0; i < ListView_GetItemCount(hTree); i++)

+ {

+ memset(&item, 0, sizeof(LVITEM));

+ item.mask = LVIF_PARAM;

+ item.iItem = i;

+

+ if (ListView_GetItem (hTree, &item) == FALSE)

+ return FALSE;

+ else

+ {

+ if (HIWORD (item.lParam) == nLetter)

+ {

+ memset(&item, 0, sizeof(LVITEM));

+ item.state = LVIS_FOCUSED|LVIS_SELECTED;

+ item.stateMask = LVIS_FOCUSED|LVIS_SELECTED;

+ item.mask = LVIF_STATE;

+ item.iItem = i;

+ SendMessage(hTree, LVM_SETITEMSTATE, i, (LPARAM) &item);

+ return TRUE;

+ }

+ }

+ }

+

+ return TRUE;

+}

+

+

+static void LaunchVolCreationWizard (HWND hwndDlg, const char *arg)

+{

+ char t[TC_MAX_PATH] = {'"',0};

+ char *tmp;

+

+ GetModuleFileName (NULL, t+1, sizeof(t)-1);

+

+ tmp = strrchr (t, '\\');

+ if (tmp)

+ {

+ STARTUPINFO si;

+ PROCESS_INFORMATION pi;

+ ZeroMemory (&si, sizeof (si));

+

+ strcpy (++tmp, "TrueCrypt Format.exe\"");

+

+ if (!FileExists(t))

+ Error ("VOL_CREATION_WIZARD_NOT_FOUND"); // Display a user-friendly error message and advise what to do

+

+ if (strlen (arg) > 0)

+ {

+ strcat (t, " ");

+ strcat (t, arg);

+ }

+

+ if (!CreateProcess (NULL, (LPSTR) t, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi))

+ {

+ handleWin32Error (hwndDlg);

+ }

+ else

+ {

+ CloseHandle (pi.hProcess);

+ CloseHandle (pi.hThread);

+ }

+ }

+}

+

+

+// Fills drive list

+// drive>0 = update only the corresponding drive subitems

+void LoadDriveLetters (HWND hTree, int drive)

+{

+ // Remember the top-most visible item

+ int lastTopMostVisibleItem = ListView_GetTopIndex (hTree);

+

+ char *szDriveLetters[]=

+ {"A:", "B:", "C:", "D:",

+ "E:", "F:", "G:", "H:", "I:", "J:", "K:",

+ "L:", "M:", "N:", "O:", "P:", "Q:", "R:",

+ "S:", "T:", "U:", "V:", "W:", "X:", "Y:",

+ "Z:"};

+

+ DWORD dwResult;

+ BOOL bResult;

+ DWORD dwUsedDrives;

+ MOUNT_LIST_STRUCT driver;

+ VOLUME_PROPERTIES_STRUCT propSysEnc;

+ char sysDriveLetter = 0;

+

+ BOOL bSysEnc = FALSE;

+ BOOL bWholeSysDriveEncryption = FALSE;

+

+ LVITEM listItem;

+ int item = 0;

+ char i;

+

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ if (bSysEnc = BootEncStatus.DriveMounted)

+ {

+ BootEncObj->GetVolumeProperties (&propSysEnc);

+ }

+ }

+ catch (...)

+ {

+ bSysEnc = FALSE;

+ }

+

+ ZeroMemory (&driver, sizeof (driver));

+ bResult = DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &driver,

+ sizeof (driver), &driver, sizeof (driver), &dwResult,

+ NULL);

+ memcpy (&LastKnownMountList, &driver, sizeof (driver));

+

+ if (bResult == FALSE)

+ {

+ KillTimer (MainDlg, TIMER_ID_MAIN);

+ handleWin32Error (hTree);

+ AbortProcessSilent();

+ }

+

+ LastKnownLogicalDrives = dwUsedDrives = GetLogicalDrives ();

+ if (dwUsedDrives == 0)

+ Warning ("DRIVELETTERS");

+

+ if(drive == 0)

+ ListView_DeleteAllItems(hTree);

+

+ if (bSysEnc)

+ {

+ bWholeSysDriveEncryption = WholeSysDriveEncryption (TRUE);

+

+ sysDriveLetter = GetSystemDriveLetter ();

+ }

+

+ /* System drive */

+

+ if (bWholeSysDriveEncryption)

+ {

+ int curDrive = 0;

+

+ if (drive > 0)

+ {

+ LVITEM tmp;

+ memset(&tmp, 0, sizeof(LVITEM));

+ tmp.mask = LVIF_PARAM;

+ tmp.iItem = item;

+ if (ListView_GetItem (hTree, &tmp))

+ curDrive = HIWORD(tmp.lParam);

+ }

+

+ {

+ char szTmp[1024];

+ wchar_t szTmpW[1024];

+

+ memset(&listItem, 0, sizeof(listItem));

+

+ listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;

+ listItem.iImage = 2;

+ listItem.iItem = item++;

+

+ listItem.pszText = szTmp;

+ strcpy (szTmp, " ");

+

+ listItem.lParam = MAKELONG (TC_MLIST_ITEM_SYS_DRIVE, ENC_SYSDRIVE_PSEUDO_DRIVE_LETTER);

+

+ if(drive == 0)

+ ListView_InsertItem (hTree, &listItem);

+ else

+ ListView_SetItem (hTree, &listItem);

+

+ listItem.mask=LVIF_TEXT;

+

+ // Fully encrypted

+ if (SysDriveOrPartitionFullyEncrypted (TRUE))

+ {

+ wcscpy (szTmpW, GetString ("SYSTEM_DRIVE"));

+ }

+ else

+ {

+ // Partially encrypted

+

+ if (BootEncStatus.SetupInProgress)

+ {

+ // Currently encrypting/decrypting

+

+ if (BootEncStatus.SetupMode != SetupDecryption)

+ {

+ _snwprintf (szTmpW,

+ sizeof szTmpW/2,

+ GetString ("SYSTEM_DRIVE_ENCRYPTING"),

+ (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);

+ }

+ else

+ {

+ _snwprintf (szTmpW,

+ sizeof szTmpW/2,

+ GetString ("SYSTEM_DRIVE_DECRYPTING"),

+ 100.0 - ((double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0));

+ }

+ }

+ else

+ {

+ _snwprintf (szTmpW,

+ sizeof szTmpW/2,

+ GetString ("SYSTEM_DRIVE_PARTIALLY_ENCRYPTED"),

+ (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);

+ }

+ }

+

+ ListSubItemSetW (hTree, listItem.iItem, 1, szTmpW);

+

+ GetSizeString (GetSysEncDeviceSize(TRUE), szTmpW);

+ ListSubItemSetW (hTree, listItem.iItem, 2, szTmpW);

+

+ EAGetName (szTmp, propSysEnc.ea);

+ listItem.iSubItem = 3;

+ ListView_SetItem (hTree, &listItem);

+

+ ListSubItemSetW (hTree, listItem.iItem, 4, GetString (IsHiddenOSRunning() ? "HIDDEN" : "SYSTEM_VOLUME_TYPE_ADJECTIVE"));

+ }

+ }

+

+ /* Drive letters */

+

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

+ {

+ int curDrive = 0;

+

+ BOOL bSysEncPartition = (bSysEnc && !bWholeSysDriveEncryption && sysDriveLetter == *((char *) szDriveLetters[i]));

+

+ if (drive > 0)

+ {

+ LVITEM tmp;

+ memset(&tmp, 0, sizeof(LVITEM));

+ tmp.mask = LVIF_PARAM;

+ tmp.iItem = item;

+ if (ListView_GetItem (hTree, &tmp))

+ curDrive = HIWORD(tmp.lParam);

+ }

+

+ if (driver.ulMountedDrives & (1 << i)

+ || bSysEncPartition)

+ {

+ char szTmp[1024];

+ wchar_t szTmpW[1024];

+ wchar_t *ws;

+

+ memset(&listItem, 0, sizeof(listItem));

+

+ listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;

+ listItem.iImage = bSysEncPartition ? 2 : 1;

+ listItem.iItem = item++;

+

+ if (drive > 0 && drive != curDrive)

+ continue;

+

+ listItem.lParam = MAKELONG (

+ bSysEncPartition ? TC_MLIST_ITEM_SYS_PARTITION : TC_MLIST_ITEM_NONSYS_VOL,

+ i + 'A');

+

+ listItem.pszText = szDriveLetters[i];

+

+ if (drive == 0)

+ ListView_InsertItem (hTree, &listItem);

+ else

+ ListView_SetItem (hTree, &listItem);

+

+ listItem.mask=LVIF_TEXT;

+ listItem.pszText = szTmp;

+

+ if (bSysEncPartition)

+ {

+ // Fully encrypted

+ if (SysDriveOrPartitionFullyEncrypted (TRUE))

+ {

+ wcscpy (szTmpW, GetString (IsHiddenOSRunning() ? "HIDDEN_SYSTEM_PARTITION" : "SYSTEM_PARTITION"));

+ }

+ else

+ {

+ // Partially encrypted

+

+ if (BootEncStatus.SetupInProgress)

+ {

+ // Currently encrypting/decrypting

+

+ if (BootEncStatus.SetupMode != SetupDecryption)

+ {

+ _snwprintf (szTmpW,

+ sizeof szTmpW/2,

+ GetString ("SYSTEM_PARTITION_ENCRYPTING"),

+ (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);

+ }

+ else

+ {

+ _snwprintf (szTmpW,

+ sizeof szTmpW/2,

+ GetString ("SYSTEM_PARTITION_DECRYPTING"),

+ 100.0 - ((double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0));

+ }

+ }

+ else

+ {

+ _snwprintf (szTmpW,

+ sizeof szTmpW/2,

+ GetString ("SYSTEM_PARTITION_PARTIALLY_ENCRYPTED"),

+ (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);

+ }

+ }

+

+ ListSubItemSetW (hTree, listItem.iItem, 1, szTmpW);

+ }

+ else

+ {

+ ToSBCS (driver.wszVolume[i]);

+ char *path = (char *) driver.wszVolume[i];

+

+ if (memcmp (path, "\\??\\", 4) == 0)

+ path += 4;

+

+ listItem.iSubItem = 1;

+

+ wstring label = GetFavoriteVolumeLabel (path);

+ if (!label.empty())

+ ListSubItemSetW (hTree, listItem.iItem, 1, (wchar_t *) label.c_str());

+ else

+ ListSubItemSet (hTree, listItem.iItem, 1, (char *) FitPathInGfxWidth (hTree, hUserFont, ListView_GetColumnWidth (hTree, 1) - GetTextGfxWidth (hTree, L"___", hUserFont), path).c_str());

+ }

+

+ GetSizeString (bSysEncPartition ? GetSysEncDeviceSize(TRUE) : driver.diskLength[i], szTmpW);

+ ListSubItemSetW (hTree, listItem.iItem, 2, szTmpW);

+

+ EAGetName (szTmp, bSysEncPartition ? propSysEnc.ea : driver.ea[i]);

+ listItem.iSubItem = 3;

+ ListView_SetItem (hTree, &listItem);

+

+ if (bSysEncPartition)

+ {

+ ws = GetString (IsHiddenOSRunning() ? "HIDDEN" : "SYSTEM_VOLUME_TYPE_ADJECTIVE");

+ VolumeNotificationsList.bHidVolDamagePrevReported[i] = FALSE;

+ ListSubItemSetW (hTree, listItem.iItem, 4, ws);

+ }

+ else

+ {

+ switch (driver.volumeType[i])

+ {

+ case PROP_VOL_TYPE_NORMAL:

+ ws = GetString ("NORMAL");

+ break;

+ case PROP_VOL_TYPE_HIDDEN:

+ ws = GetString ("HIDDEN");

+ break;

+ case PROP_VOL_TYPE_OUTER:

+ ws = GetString ("OUTER"); // Normal/outer volume (hidden volume protected)

+ break;

+ case PROP_VOL_TYPE_OUTER_VOL_WRITE_PREVENTED:

+ ws = GetString ("OUTER_VOL_WRITE_PREVENTED"); // Normal/outer volume (hidden volume protected AND write denied)

+ break;

+ default:

+ ws = L"?";

+ }

+ ListSubItemSetW (hTree, listItem.iItem, 4, ws);

+

+ if (driver.volumeType[i] == PROP_VOL_TYPE_OUTER_VOL_WRITE_PREVENTED) // Normal/outer volume (hidden volume protected AND write denied)

+ {

+ if (!VolumeNotificationsList.bHidVolDamagePrevReported[i])

+ {

+ wchar_t szTmp[4096];

+

+ VolumeNotificationsList.bHidVolDamagePrevReported[i] = TRUE;

+ swprintf (szTmp, GetString ("DAMAGE_TO_HIDDEN_VOLUME_PREVENTED"), i+'A');

+ SetForegroundWindow (GetParent(hTree));

+ MessageBoxW (GetParent(hTree), szTmp, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

+ }

+ }

+ else

+ {

+ VolumeNotificationsList.bHidVolDamagePrevReported[i] = FALSE;

+ }

+ }

+ }

+ else

+ {

+ VolumeNotificationsList.bHidVolDamagePrevReported[i] = FALSE;

+

+ if (!(dwUsedDrives & 1 << i))

+ {

+ if(drive > 0 && drive != HIWORD (GetSelectedLong (hTree)))

+ {

+ item++;

+ continue;

+ }

+

+ memset(&listItem,0,sizeof(listItem));

+

+ listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;

+ listItem.iImage = 0;

+ listItem.iItem = item++;

+ listItem.pszText = szDriveLetters[i];

+ listItem.lParam = MAKELONG (TC_MLIST_ITEM_FREE, i + 'A');

+

+ if(drive == 0)

+ ListView_InsertItem (hTree, &listItem);

+ else

+ ListView_SetItem (hTree, &listItem);

+

+ listItem.mask=LVIF_TEXT;

+ listItem.pszText = "";

+ listItem.iSubItem = 1;

+ ListView_SetItem (hTree, &listItem);

+ listItem.iSubItem = 2;

+ ListView_SetItem (hTree, &listItem);

+ listItem.iSubItem = 3;

+ ListView_SetItem (hTree, &listItem);

+ listItem.iSubItem = 4;

+ ListView_SetItem (hTree, &listItem);

+

+ }

+ }

+ }

+

+ // Restore the original scroll position (the topmost item that was visible when we were called) and the

+ // last selected item.

+ SetListScrollHPos (hTree, lastTopMostVisibleItem);

+ SelectItem (hTree, 0);

+}

+

+static void PasswordChangeEnable (HWND hwndDlg, int button, int passwordId, BOOL keyFilesEnabled,

+ int newPasswordId, int newVerifyId, BOOL newKeyFilesEnabled)

+{

+ char password[MAX_PASSWORD + 1];

+ char newPassword[MAX_PASSWORD + 1];

+ char newVerify[MAX_PASSWORD + 1];

+ BOOL bEnable = TRUE;

+

+ GetWindowText (GetDlgItem (hwndDlg, passwordId), password, sizeof (password));

+

+ if (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF)

+ newKeyFilesEnabled = keyFilesEnabled;

+

+ switch (pwdChangeDlgMode)

+ {

+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:

+ case PCDM_ADD_REMOVE_VOL_KEYFILES:

+ case PCDM_CHANGE_PKCS5_PRF:

+ memcpy (newPassword, password, sizeof (newPassword));

+ memcpy (newVerify, password, sizeof (newVerify));

+ break;

+

+ default:

+ GetWindowText (GetDlgItem (hwndDlg, newPasswordId), newPassword, sizeof (newPassword));

+ GetWindowText (GetDlgItem (hwndDlg, newVerifyId), newVerify, sizeof (newVerify));

+ }

+

+ if (!keyFilesEnabled && strlen (password) < MIN_PASSWORD)

+ bEnable = FALSE;

+ else if (strcmp (newPassword, newVerify) != 0)

+ bEnable = FALSE;

+ else if (!newKeyFilesEnabled && strlen (newPassword) < MIN_PASSWORD)

+ bEnable = FALSE;

+

+ burn (password, sizeof (password));

+ burn (newPassword, sizeof (newPassword));

+ burn (newVerify, sizeof (newVerify));

+

+ EnableWindow (GetDlgItem (hwndDlg, button), bEnable);

+}

+

+

+/* Except in response to the WM_INITDIALOG message, the dialog box procedure

+ should return nonzero if it processes the message, and zero if it does

+ not. - see DialogProc */

+BOOL CALLBACK PasswordChangeDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+{

+ static KeyFilesDlgParam newKeyFilesParam;

+

+ WORD lw = LOWORD (wParam);

+ WORD hw = HIWORD (wParam);

+

+ switch (msg)

+ {

+ case WM_INITDIALOG:

+ {

+ LPARAM nIndex;

+ HWND hComboBox = GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID);

+ int i;

+

+ ZeroMemory (&newKeyFilesParam, sizeof (newKeyFilesParam));

+

+ SetWindowTextW (hwndDlg, GetString ("IDD_PASSWORDCHANGE_DLG"));

+ LocalizeDialog (hwndDlg, "IDD_PASSWORDCHANGE_DLG");

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);

+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);

+ SendMessage (GetDlgItem (hwndDlg, IDC_VERIFY), EM_LIMITTEXT, MAX_PASSWORD, 0);

+ EnableWindow (GetDlgItem (hwndDlg, IDOK), FALSE);

+

+ SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, KeyFilesEnable);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES), TRUE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_NEW_KEYFILES), TRUE);

+

+ SendMessage (hComboBox, CB_RESETCONTENT, 0, 0);

+

+ nIndex = SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("UNCHANGED"));

+ SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0);

+

+ for (i = FIRST_PRF_ID; i <= LAST_PRF_ID; i++)

+ {

+ if (!HashIsDeprecated (i))

+ {

+ nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) get_pkcs5_prf_name(i));

+ SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) i);

+ }

+ }

+

+ SendMessage (hComboBox, CB_SETCURSEL, 0, 0);

+

+ switch (pwdChangeDlgMode)

+ {

+ case PCDM_CHANGE_PKCS5_PRF:

+ SetWindowTextW (hwndDlg, GetString ("IDD_PCDM_CHANGE_PKCS5_PRF"));

+ LocalizeDialog (hwndDlg, "IDD_PCDM_CHANGE_PKCS5_PRF");

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_VERIFY), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_NEW_KEYFILES), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_NEW_KEYFILES), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_NEW_PASSWORD), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_CONFIRM_PASSWORD), FALSE);

+ break;

+

+ case PCDM_ADD_REMOVE_VOL_KEYFILES:

+ SetWindowTextW (hwndDlg, GetString ("IDD_PCDM_ADD_REMOVE_VOL_KEYFILES"));

+ LocalizeDialog (hwndDlg, "IDD_PCDM_ADD_REMOVE_VOL_KEYFILES");

+ newKeyFilesParam.EnableKeyFiles = TRUE;

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_VERIFY), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_NEW_PASSWORD), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_CONFIRM_PASSWORD), FALSE);

+ break;

+

+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:

+ newKeyFilesParam.EnableKeyFiles = FALSE;

+ SetWindowTextW (hwndDlg, GetString ("IDD_PCDM_REMOVE_ALL_KEYFILES_FROM_VOL"));

+ LocalizeDialog (hwndDlg, "IDD_PCDM_REMOVE_ALL_KEYFILES_FROM_VOL");

+ KeyFilesEnable = TRUE;

+ SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, TRUE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES), TRUE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_KEYFILES), TRUE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_VERIFY), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_NEW_KEYFILES), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_NEW_KEYFILES), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_NEW_PASSWORD), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_CONFIRM_PASSWORD), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_PKCS5_PRF), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), FALSE);

+ break;

+

+ case PCDM_CHANGE_PASSWORD:

+ default:

+ // NOP

+ break;

+ };

+

+ if (bSysEncPwdChangeDlgMode)

+ {

+ ToBootPwdField (hwndDlg, IDC_PASSWORD);

+ ToBootPwdField (hwndDlg, IDC_VERIFY);

+ ToBootPwdField (hwndDlg, IDC_OLD_PASSWORD);

+

+ if ((DWORD) GetKeyboardLayout (NULL) != 0x00000409 && (DWORD) GetKeyboardLayout (NULL) != 0x04090409)

+ {

+ DWORD keybLayout = (DWORD) LoadKeyboardLayout ("00000409", KLF_ACTIVATE);

+

+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

+ {

+ Error ("CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION");

+ EndDialog (hwndDlg, IDCANCEL);

+ return 0;

+ }

+

+ bKeyboardLayoutChanged = TRUE;

+ }

+

+ ShowWindow(GetDlgItem(hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW), SW_HIDE);

+ ShowWindow(GetDlgItem(hwndDlg, IDC_SHOW_PASSWORD_CHPWD_ORI), SW_HIDE);

+

+ if (SetTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD, TIMER_INTERVAL_KEYB_LAYOUT_GUARD, NULL) == 0)

+ {

+ Error ("CANNOT_SET_TIMER");

+ EndDialog (hwndDlg, IDCANCEL);

+ return 0;

+ }

+

+ newKeyFilesParam.EnableKeyFiles = FALSE;

+ KeyFilesEnable = FALSE;

+ SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_KEYFILES), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_NEW_KEYFILES), FALSE);

+ }

+

+ CheckCapsLock (hwndDlg, FALSE);

+

+ return 0;

+ }

+

+ case WM_TIMER:

+ switch (wParam)

+ {

+ case TIMER_ID_KEYB_LAYOUT_GUARD:

+ if (bSysEncPwdChangeDlgMode)

+ {

+ DWORD keybLayout = (DWORD) GetKeyboardLayout (NULL);

+

+ /* Watch the keyboard layout */

+

+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

+ {

+ // Keyboard layout is not standard US

+

+ // Attempt to wipe passwords stored in the input field buffers

+ char tmp[MAX_PASSWORD+1];

+ memset (tmp, 'X', MAX_PASSWORD);

+ tmp [MAX_PASSWORD] = 0;

+ SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);

+

+ SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), "");

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), "");

+ SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), "");

+

+ keybLayout = (DWORD) LoadKeyboardLayout ("00000409", KLF_ACTIVATE);

+

+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

+ {

+ KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);

+ Error ("CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION");

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+

+ bKeyboardLayoutChanged = TRUE;

+

+ wchar_t szTmp [4096];

+ wcscpy (szTmp, GetString ("KEYB_LAYOUT_CHANGE_PREVENTED"));

+ wcscat (szTmp, L"\n\n");

+ wcscat (szTmp, GetString ("KEYB_LAYOUT_SYS_ENC_EXPLANATION"));

+ MessageBoxW (MainDlg, szTmp, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

+ }

+

+

+ /* Watch the right Alt key (which is used to enter various characters on non-US keyboards) */

+

+ if (bKeyboardLayoutChanged && !bKeybLayoutAltKeyWarningShown)

+ {

+ if (GetAsyncKeyState (VK_RMENU) < 0)

+ {

+ bKeybLayoutAltKeyWarningShown = TRUE;

+

+ wchar_t szTmp [4096];

+ wcscpy (szTmp, GetString ("ALT_KEY_CHARS_NOT_FOR_SYS_ENCRYPTION"));

+ wcscat (szTmp, L"\n\n");

+ wcscat (szTmp, GetString ("KEYB_LAYOUT_SYS_ENC_EXPLANATION"));

+ MessageBoxW (MainDlg, szTmp, lpszTitle, MB_ICONINFORMATION | MB_SETFOREGROUND | MB_TOPMOST);

+ }

+ }

+ }

+ return 1;

+ }

+ return 0;

+

+ case WM_COMMAND:

+ if (lw == IDCANCEL)

+ {

+ // Attempt to wipe passwords stored in the input field buffers

+ char tmp[MAX_PASSWORD+1];

+ memset (tmp, 'X', MAX_PASSWORD);

+ tmp[MAX_PASSWORD] = 0;

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);

+ RestoreDefaultKeyFilesParam ();

+

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+

+ if (hw == EN_CHANGE)

+ {

+ PasswordChangeEnable (hwndDlg, IDOK,

+ IDC_OLD_PASSWORD,

+ KeyFilesEnable && FirstKeyFile != NULL,

+ IDC_PASSWORD, IDC_VERIFY,

+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);

+

+ return 1;

+ }

+

+ if (lw == IDC_KEYFILES)

+ {

+ if (bSysEncPwdChangeDlgMode)

+ {

+ Warning ("KEYFILES_NOT_SUPPORTED_FOR_SYS_ENCRYPTION");

+ return 1;

+ }

+

+ KeyFilesDlgParam param;

+ param.EnableKeyFiles = KeyFilesEnable;

+ param.FirstKeyFile = FirstKeyFile;

+

+ if (IDOK == DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,

+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &param))

+ {

+ KeyFilesEnable = param.EnableKeyFiles;

+ FirstKeyFile = param.FirstKeyFile;

+

+ SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, KeyFilesEnable);

+ }

+

+ PasswordChangeEnable (hwndDlg, IDOK,

+ IDC_OLD_PASSWORD,

+ KeyFilesEnable && FirstKeyFile != NULL,

+ IDC_PASSWORD, IDC_VERIFY,

+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);

+

+ return 1;

+ }

+

+

+ if (lw == IDC_NEW_KEYFILES)

+ {

+ if (bSysEncPwdChangeDlgMode)

+ {

+ Warning ("KEYFILES_NOT_SUPPORTED_FOR_SYS_ENCRYPTION");

+ return 1;

+ }

+

+ if (IDOK == DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,

+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &newKeyFilesParam))

+ {

+ SetCheckBox (hwndDlg, IDC_ENABLE_NEW_KEYFILES, newKeyFilesParam.EnableKeyFiles);

+

+ VerifyPasswordAndUpdate (hwndDlg, GetDlgItem (hwndDlg, IDOK), GetDlgItem (hwndDlg, IDC_PASSWORD),

+ GetDlgItem (hwndDlg, IDC_VERIFY), NULL, NULL,

+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);

+ }

+

+ PasswordChangeEnable (hwndDlg, IDOK,

+ IDC_OLD_PASSWORD,

+ KeyFilesEnable && FirstKeyFile != NULL,

+ IDC_PASSWORD, IDC_VERIFY,

+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);

+

+ return 1;

+ }

+

+ if (lw == IDC_ENABLE_KEYFILES)

+ {

+ KeyFilesEnable = GetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES);

+

+ PasswordChangeEnable (hwndDlg, IDOK,

+ IDC_OLD_PASSWORD,

+ KeyFilesEnable && FirstKeyFile != NULL,

+ IDC_PASSWORD, IDC_VERIFY,

+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);

+

+ return 1;

+ }

+

+ if (lw == IDC_ENABLE_NEW_KEYFILES)

+ {

+ newKeyFilesParam.EnableKeyFiles = GetCheckBox (hwndDlg, IDC_ENABLE_NEW_KEYFILES);

+

+ PasswordChangeEnable (hwndDlg, IDOK,

+ IDC_OLD_PASSWORD,

+ KeyFilesEnable && FirstKeyFile != NULL,

+ IDC_PASSWORD, IDC_VERIFY,

+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);

+

+ return 1;

+ }

+

+ if (hw == CBN_SELCHANGE)

+ {

+ switch (lw)

+ {

+ case IDC_PKCS5_PRF_ID:

+ if (bSysEncPwdChangeDlgMode)

+ {

+ int new_hash_algo_id = SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA,

+ SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

+

+ if (new_hash_algo_id != 0 && new_hash_algo_id != DEFAULT_HASH_ALGORITHM_BOOT)

+ {

+ int new_hash_algo_id = DEFAULT_HASH_ALGORITHM_BOOT;

+ Info ("ALGO_NOT_SUPPORTED_FOR_SYS_ENCRYPTION");

+ SelectAlgo (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), &new_hash_algo_id);

+ }

+ }

+ break;

+ }

+ return 1;

+

+ }

+

+ if (lw == IDC_SHOW_PASSWORD_CHPWD_ORI)

+ {

+ SendMessage (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD),

+ EM_SETPASSWORDCHAR,

+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_ORI) ? 0 : '*',

+ 0);

+ InvalidateRect (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), NULL, TRUE);

+ return 1;

+ }

+

+ if (lw == IDC_SHOW_PASSWORD_CHPWD_NEW)

+ {

+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD),

+ EM_SETPASSWORDCHAR,

+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW) ? 0 : '*',

+ 0);

+ SendMessage (GetDlgItem (hwndDlg, IDC_VERIFY),

+ EM_SETPASSWORDCHAR,

+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW) ? 0 : '*',

+ 0);

+ InvalidateRect (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL, TRUE);

+ InvalidateRect (GetDlgItem (hwndDlg, IDC_VERIFY), NULL, TRUE);

+ return 1;

+ }

+

+ if (lw == IDOK)

+ {

+ HWND hParent = GetParent (hwndDlg);

+ Password oldPassword;

+ Password newPassword;

+ int nStatus;

+ int pkcs5 = SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA,

+ SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

+

+ if (!CheckPasswordCharEncoding (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL))

+ {

+ Error ("UNSUPPORTED_CHARS_IN_PWD");

+ return 1;

+ }

+

+ if (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF)

+ {

+ newKeyFilesParam.EnableKeyFiles = KeyFilesEnable;

+ }

+ else if (!(newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL)

+ && pwdChangeDlgMode == PCDM_CHANGE_PASSWORD)

+ {

+ if (!CheckPasswordLength (hwndDlg, GetDlgItem (hwndDlg, IDC_PASSWORD)))

+ return 1;

+ }

+

+ GetWindowText (GetDlgItem (hParent, IDC_VOLUME), szFileName, sizeof (szFileName));

+

+ GetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), (LPSTR) oldPassword.Text, sizeof (oldPassword.Text));

+ oldPassword.Length = strlen ((char *) oldPassword.Text);

+

+ switch (pwdChangeDlgMode)

+ {

+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:

+ case PCDM_ADD_REMOVE_VOL_KEYFILES:

+ case PCDM_CHANGE_PKCS5_PRF:

+ memcpy (newPassword.Text, oldPassword.Text, sizeof (newPassword.Text));

+ newPassword.Length = strlen ((char *) oldPassword.Text);

+ break;

+

+ default:

+ GetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), (LPSTR) newPassword.Text, sizeof (newPassword.Text));

+ newPassword.Length = strlen ((char *) newPassword.Text);

+ }

+

+ WaitCursor ();

+

+ if (KeyFilesEnable)

+ KeyFilesApply (&oldPassword, FirstKeyFile);

+

+ if (newKeyFilesParam.EnableKeyFiles)

+ {

+ if (!KeyFilesApply (&newPassword, pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF ? FirstKeyFile : newKeyFilesParam.FirstKeyFile))

+ {

+ nStatus = ERR_DONT_REPORT;

+ goto err;

+ }

+ }

+

+ if (bSysEncPwdChangeDlgMode)

+ {

+ // System

+

+ pkcs5 = 0; // PKCS-5 PRF unchanged (currently system encryption supports only RIPEMD-160)

+

+ try

+ {

+ nStatus = BootEncObj->ChangePassword (&oldPassword, &newPassword, pkcs5);

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ nStatus = ERR_OS_ERROR;

+ }

+ }

+ else

+ {

+ // Non-system

+

+ nStatus = ChangePwd (szFileName, &oldPassword, &newPassword, pkcs5, hwndDlg);

+

+ if (nStatus == ERR_OS_ERROR

+ && GetLastError () == ERROR_ACCESS_DENIED

+ && IsUacSupported ()

+ && IsVolumeDeviceHosted (szFileName))

+ {

+ nStatus = UacChangePwd (szFileName, &oldPassword, &newPassword, pkcs5, hwndDlg);

+ }

+ }

+

+err:

+ burn (&oldPassword, sizeof (oldPassword));

+ burn (&newPassword, sizeof (newPassword));

+

+ NormalCursor ();

+

+ if (nStatus == 0)

+ {

+ // Attempt to wipe passwords stored in the input field buffers

+ char tmp[MAX_PASSWORD+1];

+ memset (tmp, 'X', MAX_PASSWORD);

+ tmp[MAX_PASSWORD] = 0;

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);

+

+ KeyFileRemoveAll (&newKeyFilesParam.FirstKeyFile);

+ RestoreDefaultKeyFilesParam ();

+

+ if (bSysEncPwdChangeDlgMode)

+ {

+ KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);

+ }

+

+ EndDialog (hwndDlg, IDOK);

+ }

+ return 1;

+ }

+ return 0;

+ }

+

+ return 0;

+}

+

+static char PasswordDlgVolume[MAX_PATH];

+static BOOL PasswordDialogDisableMountOptions;

+static char *PasswordDialogTitleStringId;

+

+/* Except in response to the WM_INITDIALOG message, the dialog box procedure

+ should return nonzero if it processes the message, and zero if it does

+ not. - see DialogProc */

+BOOL CALLBACK PasswordDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+{

+ WORD lw = LOWORD (wParam);

+ static Password *szXPwd;

+

+ switch (msg)

+ {

+ case WM_INITDIALOG:

+ {

+ szXPwd = (Password *) lParam;

+ LocalizeDialog (hwndDlg, "IDD_PASSWORD_DLG");

+ DragAcceptFiles (hwndDlg, TRUE);

+

+ if (PasswordDialogTitleStringId)

+ {

+ SetWindowTextW (hwndDlg, GetString (PasswordDialogTitleStringId));

+ }

+ else if (strlen (PasswordDlgVolume) > 0)

+ {

+ wchar_t s[1024];

+ RECT rect;

+ GetWindowRect (hwndDlg, &rect);

+

+ wstring label = GetFavoriteVolumeLabel (PasswordDlgVolume);

+ if (!label.empty())

+ {

+ wsprintfW (s, GetString ("ENTER_PASSWORD_FOR_LABEL"), label.c_str());

+ }

+ else

+ {

+ wsprintfW (s, GetString ("ENTER_PASSWORD_FOR"), "___");

+ wsprintfW (s, GetString ("ENTER_PASSWORD_FOR"), FitPathInGfxWidth (hwndDlg, WindowTitleBarFont, rect.right - rect.left - GetTextGfxWidth (hwndDlg, s, WindowTitleBarFont), PasswordDlgVolume).c_str());

+ }

+

+ SetWindowTextW (hwndDlg, s);

+ }

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);

+ SendMessage (GetDlgItem (hwndDlg, IDC_CACHE), BM_SETCHECK, bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);

+

+ mountOptions.PartitionInInactiveSysEncScope = bPrebootPasswordDlgMode;

+

+ if (bPrebootPasswordDlgMode)

+ {

+ SendMessage (hwndDlg, TC_APPMSG_PREBOOT_PASSWORD_MODE, 0, 0);

+ }

+

+ if (PasswordDialogDisableMountOptions)

+ {

+ EnableWindow (GetDlgItem (hwndDlg, IDC_CACHE), FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_MOUNT_OPTIONS), FALSE);

+ }

+

+ if (!SetForegroundWindow (hwndDlg) && (FavoriteMountOnArrivalInProgress || LogOn))

+ {

+ SetWindowPos (hwndDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

+

+ FLASHWINFO flash;

+ flash.cbSize = sizeof (flash);

+ flash.dwFlags = FLASHW_ALL | FLASHW_TIMERNOFG;

+ flash.dwTimeout = 0;

+ flash.hwnd = hwndDlg;

+ flash.uCount = 0;

+

+ FlashWindowEx (&flash);

+

+ SetWindowPos (hwndDlg, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

+ }

+ }

+ return 0;

+

+ case TC_APPMSG_PREBOOT_PASSWORD_MODE:

+ {

+ ToBootPwdField (hwndDlg, IDC_PASSWORD);

+

+ // Attempt to wipe the password stored in the input field buffer

+ char tmp[MAX_PASSWORD+1];

+ memset (tmp, 'X', MAX_PASSWORD);

+ tmp [MAX_PASSWORD] = 0;

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), "");

+

+ sprintf (OrigKeyboardLayout, "%08X", (DWORD) GetKeyboardLayout (NULL) & 0xFFFF);

+

+ DWORD keybLayout = (DWORD) LoadKeyboardLayout ("00000409", KLF_ACTIVATE);

+

+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

+ {

+ Error ("CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION");

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+

+ if (SetTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD, TIMER_INTERVAL_KEYB_LAYOUT_GUARD, NULL) == 0)

+ {

+ Error ("CANNOT_SET_TIMER");

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+

+ SetCheckBox (hwndDlg, IDC_SHOW_PASSWORD, FALSE);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD), FALSE);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_SETPASSWORDCHAR, '*', 0);

+ InvalidateRect (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL, TRUE);

+

+ bPrebootPasswordDlgMode = TRUE;

+ }

+ return 1;

+

+ case WM_TIMER:

+ switch (wParam)

+ {

+ case TIMER_ID_KEYB_LAYOUT_GUARD:

+ if (bPrebootPasswordDlgMode)

+ {

+ DWORD keybLayout = (DWORD) GetKeyboardLayout (NULL);

+

+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

+ {

+ // Keyboard layout is not standard US

+

+ // Attempt to wipe the password stored in the input field buffer

+ char tmp[MAX_PASSWORD+1];

+ memset (tmp, 'X', MAX_PASSWORD);

+ tmp [MAX_PASSWORD] = 0;

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), "");

+

+ keybLayout = (DWORD) LoadKeyboardLayout ("00000409", KLF_ACTIVATE);

+

+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

+ {

+ KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);

+ Error ("CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION");

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+

+ wchar_t szTmp [4096];

+ wcscpy (szTmp, GetString ("KEYB_LAYOUT_CHANGE_PREVENTED"));

+ wcscat (szTmp, L"\n\n");

+ wcscat (szTmp, GetString ("KEYB_LAYOUT_SYS_ENC_EXPLANATION"));

+ MessageBoxW (MainDlg, szTmp, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

+ }

+ }

+ return 1;

+ }

+ return 0;

+

+ case WM_COMMAND:

+

+ if (lw == IDC_MOUNT_OPTIONS)

+ {

+ DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), hwndDlg,

+ (DLGPROC) MountOptionsDlgProc, (LPARAM) &mountOptions);

+

+ if (!bPrebootPasswordDlgMode && mountOptions.PartitionInInactiveSysEncScope)

+ SendMessage (hwndDlg, TC_APPMSG_PREBOOT_PASSWORD_MODE, 0, 0);

+

+ return 1;

+ }

+

+ if (lw == IDC_SHOW_PASSWORD)

+ {

+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD),

+ EM_SETPASSWORDCHAR,

+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD) ? 0 : '*',

+ 0);

+ InvalidateRect (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL, TRUE);

+ return 1;

+ }

+

+ if (lw == IDC_KEY_FILES)

+ {

+ KeyFilesDlgParam param;

+ param.EnableKeyFiles = KeyFilesEnable;

+ param.FirstKeyFile = FirstKeyFile;

+

+ if (IDOK == DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,

+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &param))

+ {

+ KeyFilesEnable = param.EnableKeyFiles;

+ FirstKeyFile = param.FirstKeyFile;

+

+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);

+ }

+

+ return 1;

+ }

+

+ if (lw == IDC_KEYFILES_ENABLE)

+ {

+ KeyFilesEnable = GetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE);

+

+ return 1;

+ }

+

+ if (lw == IDCANCEL || lw == IDOK)

+ {

+ char tmp[MAX_PASSWORD+1];

+

+ if (lw == IDOK)

+ {

+ if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)

+ KeyFilesApply (&mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile);

+

+ GetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), (LPSTR) szXPwd->Text, MAX_PASSWORD + 1);

+ szXPwd->Length = strlen ((char *) szXPwd->Text);

+

+ bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_CACHE));

+ }

+

+ // Attempt to wipe password stored in the input field buffer

+ memset (tmp, 'X', MAX_PASSWORD);

+ tmp[MAX_PASSWORD] = 0;

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);

+

+ if (hidVolProtKeyFilesParam.FirstKeyFile != NULL)

+ {

+ KeyFileRemoveAll (&hidVolProtKeyFilesParam.FirstKeyFile);

+ hidVolProtKeyFilesParam.EnableKeyFiles = FALSE;

+ }

+

+ if (bPrebootPasswordDlgMode)

+ {

+ KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);

+

+ // Restore the original keyboard layout

+ if (LoadKeyboardLayout (OrigKeyboardLayout, KLF_ACTIVATE | KLF_SUBSTITUTE_OK) == NULL)

+ Warning ("CANNOT_RESTORE_KEYBOARD_LAYOUT");

+ }

+

+ EndDialog (hwndDlg, lw);

+ return 1;

+ }

+ return 0;

+

+ case WM_CONTEXTMENU:

+ {

+ RECT buttonRect;

+ GetWindowRect (GetDlgItem (hwndDlg, IDC_KEY_FILES), &buttonRect);

+

+ if (LOWORD (lParam) >= buttonRect.left && LOWORD (lParam) <= buttonRect.right

+ && HIWORD (lParam) >= buttonRect.top && HIWORD (lParam) <= buttonRect.bottom)

+ {

+ // The "Keyfiles" button has been right-clicked

+

+ KeyFilesDlgParam param;

+ param.EnableKeyFiles = KeyFilesEnable;

+ param.FirstKeyFile = FirstKeyFile;

+

+ POINT popupPos;

+ popupPos.x = buttonRect.left + 2;

+ popupPos.y = buttonRect.top + 2;

+

+ if (KeyfilesPopupMenu (hwndDlg, popupPos, &param))

+ {

+ KeyFilesEnable = param.EnableKeyFiles;

+ FirstKeyFile = param.FirstKeyFile;

+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);

+ }

+ }

+ }

+ break;

+

+ case WM_DROPFILES:

+ {

+ HDROP hdrop = (HDROP) wParam;

+ int i = 0, count = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);

+

+ while (count-- > 0)

+ {

+ KeyFile *kf = (KeyFile *) malloc (sizeof (KeyFile));

+ DragQueryFile (hdrop, i++, kf->FileName, sizeof (kf->FileName));

+ FirstKeyFile = KeyFileAdd (FirstKeyFile, kf);

+ KeyFilesEnable = TRUE;

+ }

+

+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);

+ DragFinish (hdrop);

+ }

+ return 1;

+ }

+

+ return 0;

+}

+

+static void PreferencesDlgEnableButtons (HWND hwndDlg)

+{

+ BOOL back = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE));

+ BOOL idle = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE));

+ BOOL installed = !IsNonInstallMode();

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL), back && installed);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_LOGON), installed);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START), back && installed);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES), installed);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_AUTO_DISMOUNT), back);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_AUTO_DISMOUNT_ON), back);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_MINUTES), back);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_LOGOFF), back);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_POWERSAVING), back);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SCREENSAVER), back);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE), back);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE_TIME), back && idle);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT), back);

+}

+

+BOOL CALLBACK PreferencesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+{

+ static BOOL PreferencesDialogActive = FALSE;

+ static HWND ActivePreferencesDialogWindow;

+

+ WORD lw = LOWORD (wParam);

+

+ switch (msg)

+ {

+ case WM_INITDIALOG:

+ {

+ if (PreferencesDialogActive)

+ {

+ ShowWindow (ActivePreferencesDialogWindow, SW_SHOW);

+ SetForegroundWindow (ActivePreferencesDialogWindow);

+ EndDialog (hwndDlg, IDCANCEL);

+ return 1;

+ }

+

+ ActivePreferencesDialogWindow = hwndDlg;

+ PreferencesDialogActive = TRUE;

+

+ LocalizeDialog (hwndDlg, "IDD_PREFERENCES_DLG");

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_OPEN_EXPLORER), BM_SETCHECK,

+ bExplore ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_USE_DIFF_TRAY_ICON_IF_VOL_MOUNTED), BM_SETCHECK,

+ bUseDifferentTrayIconIfVolMounted ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PRESERVE_TIMESTAMPS), BM_SETCHECK,

+ defaultMountOptions.PreserveTimestamp ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_EXIT), BM_SETCHECK,

+ bWipeCacheOnExit ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_AUTODISMOUNT), BM_SETCHECK,

+ bWipeCacheOnAutoDismount ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PASSWORDS), BM_SETCHECK,

+ bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_READONLY), BM_SETCHECK,

+ defaultMountOptions.ReadOnly ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_REMOVABLE), BM_SETCHECK,

+ defaultMountOptions.Removable ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START), BM_SETCHECK,

+ bStartOnLogon ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES), BM_SETCHECK,

+ bMountDevicesOnLogon ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE), BM_SETCHECK,

+ bEnableBkgTask ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL), BM_SETCHECK,

+ bCloseBkgTaskWhenNoVolumes || IsNonInstallMode() ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_LOGOFF), BM_SETCHECK,

+ bDismountOnLogOff ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_POWERSAVING), BM_SETCHECK,

+ bDismountOnPowerSaving ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SCREENSAVER), BM_SETCHECK,

+ bDismountOnScreenSaver ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT), BM_SETCHECK,

+ bForceAutoDismount ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE), BM_SETCHECK,

+ MaxVolumeIdleTime > 0 ? BST_CHECKED:BST_UNCHECKED, 0);

+

+ SetDlgItemInt (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE_TIME, abs (MaxVolumeIdleTime), FALSE);

+

+ PreferencesDlgEnableButtons (hwndDlg);

+ }

+ return 0;

+

+ case WM_COMMAND:

+

+ if (lw == IDC_PREF_BKG_TASK_ENABLE && !IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE)))

+ {

+ if (AskWarnNoYes ("CONFIRM_BACKGROUND_TASK_DISABLED") == IDNO)

+ SetCheckBox (hwndDlg, IDC_PREF_BKG_TASK_ENABLE, TRUE);

+ }

+

+ // Forced dismount disabled warning

+ if (lw == IDC_PREF_DISMOUNT_INACTIVE

+ || lw == IDC_PREF_DISMOUNT_LOGOFF

+ || lw == IDC_PREF_DISMOUNT_POWERSAVING

+ || lw == IDC_PREF_DISMOUNT_SCREENSAVER

+ || lw == IDC_PREF_FORCE_AUTO_DISMOUNT)

+ {

+ BOOL i = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE));

+ BOOL l = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_LOGOFF));

+ BOOL p = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_POWERSAVING));

+ BOOL s = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SCREENSAVER));

+ BOOL q = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT));

+

+ if (!q)

+ {

+ if (lw == IDC_PREF_FORCE_AUTO_DISMOUNT && (i || l || p || s))

+ {

+ if (AskWarnNoYes ("CONFIRM_NO_FORCED_AUTODISMOUNT") == IDNO)

+ SetCheckBox (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT, TRUE);

+ }

+ else if ((lw == IDC_PREF_DISMOUNT_INACTIVE && i

+ || lw == IDC_PREF_DISMOUNT_LOGOFF && l

+ || lw == IDC_PREF_DISMOUNT_POWERSAVING && p

+ || lw == IDC_PREF_DISMOUNT_SCREENSAVER && s))

+ Warning ("WARN_PREF_AUTO_DISMOUNT");

+ }

+

+ if (p && lw == IDC_PREF_DISMOUNT_POWERSAVING)

+ Warning ("WARN_PREF_AUTO_DISMOUNT_ON_POWER");

+ }

+

+ if (lw == IDCANCEL)

+ {

+ PreferencesDialogActive = FALSE;

+ EndDialog (hwndDlg, lw);

+ return 1;

+ }

+

+ if (lw == IDOK)

+ {

+ WaitCursor ();

+

+ bExplore = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_OPEN_EXPLORER));

+ bUseDifferentTrayIconIfVolMounted = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_USE_DIFF_TRAY_ICON_IF_VOL_MOUNTED));

+ bPreserveTimestamp = defaultMountOptions.PreserveTimestamp = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PRESERVE_TIMESTAMPS));

+ bWipeCacheOnExit = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_EXIT));

+ bWipeCacheOnAutoDismount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_AUTODISMOUNT));

+ bCacheInDriverDefault = bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PASSWORDS));

+ defaultMountOptions.ReadOnly = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_READONLY));

+ defaultMountOptions.Removable = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_REMOVABLE));

+ bEnableBkgTask = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE));

+ bCloseBkgTaskWhenNoVolumes = IsNonInstallMode() ? bCloseBkgTaskWhenNoVolumes : IsButtonChecked (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL));

+ bDismountOnLogOff = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_LOGOFF));

+ bDismountOnPowerSaving = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_POWERSAVING));

+ bDismountOnScreenSaver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SCREENSAVER));

+ bForceAutoDismount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT));

+ MaxVolumeIdleTime = GetDlgItemInt (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE_TIME, NULL, FALSE)

+ * (IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE)) ? 1 : -1);

+ bStartOnLogon = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START));

+ bMountDevicesOnLogon = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES));

+

+ ManageStartupSeq ();

+

+ SaveSettings (hwndDlg);

+

+ NormalCursor ();

+

+ PreferencesDialogActive = FALSE;

+ EndDialog (hwndDlg, lw);

+ return 1;

+ }

+

+ if (lw == IDC_MORE_SETTINGS)

+ {

+ HMENU popup = CreatePopupMenu ();

+

+ AppendMenuW (popup, MF_STRING, IDM_LANGUAGE, GetString ("IDM_LANGUAGE"));

+ AppendMenuW (popup, MF_STRING, IDM_HOTKEY_SETTINGS, GetString ("IDM_HOTKEY_SETTINGS"));

+ AppendMenuW (popup, MF_STRING, IDM_PERFORMANCE_SETTINGS, GetString ("IDM_PERFORMANCE_SETTINGS"));

+ AppendMenuW (popup, MF_STRING, IDM_SYSENC_SETTINGS, GetString ("IDM_SYSENC_SETTINGS"));

+ AppendMenuW (popup, MF_STRING, IDM_SYS_FAVORITES_SETTINGS, GetString ("IDM_SYS_FAVORITES_SETTINGS"));

+ AppendMenuW (popup, MF_STRING, IDM_DEFAULT_KEYFILES, GetString ("IDM_DEFAULT_KEYFILES"));

+ AppendMenuW (popup, MF_STRING, IDM_TOKEN_PREFERENCES, GetString ("IDM_TOKEN_PREFERENCES"));

+

+ RECT rect;

+ GetWindowRect (GetDlgItem (hwndDlg, IDC_MORE_SETTINGS), &rect);

+

+ int menuItem = TrackPopupMenu (popup, TPM_RETURNCMD | TPM_LEFTBUTTON, rect.left + 2, rect.top + 2, 0, hwndDlg, NULL);

+ DestroyMenu (popup);

+

+ SendMessage (MainDlg, WM_COMMAND, menuItem, NULL);

+ return 1;

+ }

+

+ if (HIWORD (wParam) == BN_CLICKED)

+ {

+ PreferencesDlgEnableButtons (hwndDlg);

+ return 1;

+ }

+

+ return 0;

+ }

+

+ return 0;

+}

+

+

+BOOL CALLBACK MountOptionsDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+{

+ static MountOptions *mountOptions;

+

+ WORD lw = LOWORD (wParam);

+

+ switch (msg)

+ {

+ case WM_INITDIALOG:

+ {

+ BOOL protect;

+

+ mountOptions = (MountOptions *) lParam;

+

+ LocalizeDialog (hwndDlg, "IDD_MOUNT_OPTIONS");

+

+ SendDlgItemMessage (hwndDlg, IDC_MOUNT_READONLY, BM_SETCHECK,

+ mountOptions->ReadOnly ? BST_CHECKED : BST_UNCHECKED, 0);

+ SendDlgItemMessage (hwndDlg, IDC_MOUNT_REMOVABLE, BM_SETCHECK,

+ mountOptions->Removable ? BST_CHECKED : BST_UNCHECKED, 0);

+ SendDlgItemMessage (hwndDlg, IDC_PROTECT_HIDDEN_VOL, BM_SETCHECK,

+ mountOptions->ProtectHiddenVolume ? BST_CHECKED : BST_UNCHECKED, 0);

+

+ SendDlgItemMessage (hwndDlg, IDC_PROTECT_HIDDEN_VOL, BM_SETCHECK,

+ mountOptions->ProtectHiddenVolume ? BST_CHECKED : BST_UNCHECKED, 0);

+

+ mountOptions->PartitionInInactiveSysEncScope = bPrebootPasswordDlgMode;

+

+ SendDlgItemMessage (hwndDlg, IDC_MOUNT_SYSENC_PART_WITHOUT_PBA, BM_SETCHECK,

+ bPrebootPasswordDlgMode ? BST_CHECKED : BST_UNCHECKED, 0);

+

+ SendDlgItemMessage (hwndDlg, IDC_USE_EMBEDDED_HEADER_BAK, BM_SETCHECK,

+ mountOptions->UseBackupHeader ? BST_CHECKED : BST_UNCHECKED, 0);

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_MOUNT_SYSENC_PART_WITHOUT_PBA), !bPrebootPasswordDlgMode);

+

+ protect = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL));

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));

+ EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_VOL_PROTECTION), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), protect);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_MO), protect);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_PROT_PASSWD), protect);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_HIDVOL_PROT), protect);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT), protect);

+

+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT, hidVolProtKeyFilesParam.EnableKeyFiles);

+

+ SendDlgItemMessage (hwndDlg, IDC_PASSWORD_PROT_HIDVOL, EM_LIMITTEXT, MAX_PASSWORD, 0);

+

+ if (mountOptions->ProtectedHidVolPassword.Length > 0)

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), (LPSTR) mountOptions->ProtectedHidVolPassword.Text);

+

+ ToHyperlink (hwndDlg, IDC_LINK_HIDVOL_PROTECTION_INFO);

+

+ }

+ return 0;

+

+ case WM_CONTEXTMENU:

+ {

+ RECT buttonRect;

+ GetWindowRect (GetDlgItem (hwndDlg, IDC_KEYFILES_HIDVOL_PROT), &buttonRect);

+

+ if (IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL))

+ && LOWORD (lParam) >= buttonRect.left && LOWORD (lParam) <= buttonRect.right

+ && HIWORD (lParam) >= buttonRect.top && HIWORD (lParam) <= buttonRect.bottom)

+ {

+ // The "Keyfiles" button has been right-clicked

+

+ POINT popupPos;

+ popupPos.x = buttonRect.left + 2;

+ popupPos.y = buttonRect.top + 2;

+

+ if (KeyfilesPopupMenu (hwndDlg, popupPos, &hidVolProtKeyFilesParam))

+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT, hidVolProtKeyFilesParam.EnableKeyFiles);

+ }

+ }

+ break;

+

+ case WM_COMMAND:

+

+ if (lw == IDC_KEYFILES_HIDVOL_PROT)

+ {

+ if (IDOK == DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,

+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &hidVolProtKeyFilesParam))

+ {

+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT, hidVolProtKeyFilesParam.EnableKeyFiles);

+ }

+ }

+

+ if (lw == IDC_KEYFILES_ENABLE_HIDVOL_PROT)

+ {

+ hidVolProtKeyFilesParam.EnableKeyFiles = GetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT);

+

+ return 0;

+ }

+

+ if (lw == IDC_SHOW_PASSWORD_MO)

+ {

+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL),

+ EM_SETPASSWORDCHAR,

+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD_MO) ? 0 : '*',

+ 0);

+ InvalidateRect (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), NULL, TRUE);

+ return 1;

+ }

+

+ if (lw == IDC_LINK_HIDVOL_PROTECTION_INFO)

+ {

+ Applink ("hiddenvolprotection", TRUE, "");

+ }

+

+ if (lw == IDCANCEL)

+ {

+ char tmp[MAX_PASSWORD+1];

+

+ // Cleanup

+ memset (tmp, 'X', MAX_PASSWORD);

+ tmp[MAX_PASSWORD] = 0;

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);

+

+ EndDialog (hwndDlg, lw);

+ return 1;

+ }

+

+ if (lw == IDOK)

+ {

+ char tmp[MAX_PASSWORD+1];

+

+ mountOptions->ReadOnly = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY));

+ mountOptions->Removable = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_REMOVABLE));

+ mountOptions->ProtectHiddenVolume = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL));

+ mountOptions->PartitionInInactiveSysEncScope = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_SYSENC_PART_WITHOUT_PBA));

+ mountOptions->UseBackupHeader = IsButtonChecked (GetDlgItem (hwndDlg, IDC_USE_EMBEDDED_HEADER_BAK));

+

+ if (mountOptions->ProtectHiddenVolume)

+ {

+ GetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL),

+ (LPSTR) mountOptions->ProtectedHidVolPassword.Text,

+ sizeof (mountOptions->ProtectedHidVolPassword.Text));

+

+ mountOptions->ProtectedHidVolPassword.Length = strlen ((char *) mountOptions->ProtectedHidVolPassword.Text);

+ }

+

+ // Cleanup

+ memset (tmp, 'X', MAX_PASSWORD);

+ tmp[MAX_PASSWORD] = 0;

+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);

+

+ if ((mountOptions->ProtectHiddenVolume && !bEnableBkgTask)

+ && (AskWarnYesNo ("HIDVOL_PROT_BKG_TASK_WARNING") == IDYES))

+ {

+ bEnableBkgTask = TRUE;

+ TaskBarIconAdd (MainDlg);

+ }

+

+ EndDialog (hwndDlg, lw);

+ return 1;

+ }

+

+ if (lw == IDC_MOUNT_READONLY || lw == IDC_PROTECT_HIDDEN_VOL)

+ {

+ BOOL protect;

+

+ if (lw == IDC_MOUNT_READONLY)

+ {

+ SendDlgItemMessage (hwndDlg, IDC_PROTECT_HIDDEN_VOL, BM_SETCHECK, BST_UNCHECKED, 0);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));

+ EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_VOL_PROTECTION), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));

+ }

+

+ protect = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL));

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), protect);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_PROT_PASSWD), protect);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_MO), protect);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_HIDVOL_PROT), protect);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT), protect);

+

+ return 1;

+ }

+

+ return 0;

+ }

+

+ return 0;

+}

+

+

+// Returns the block size (in bits) of the cipher with which the volume mounted as the

+// specified drive letter is encrypted. In case of a cascade of ciphers with different

+// block sizes the function returns the smallest block size.

+int GetCipherBlockSizeByDriveNo (int nDosDriveNo)

+{

+ VOLUME_PROPERTIES_STRUCT prop;

+ DWORD dwResult;

+

+ int blockSize = 0, cipherID;

+

+ memset (&prop, 0, sizeof(prop));

+ prop.driveNo = nDosDriveNo;

+

+ if (DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL))

+ {

+ for (cipherID = EAGetLastCipher (prop.ea);

+ cipherID != 0;

+ cipherID = EAGetPreviousCipher (prop.ea, cipherID))

+ {

+ if (blockSize > 0)

+ blockSize = min (blockSize, CipherGetBlockSize (cipherID) * 8);

+ else

+ blockSize = CipherGetBlockSize (cipherID) * 8;

+ }

+ }

+

+ return blockSize;

+}

+

+

+// Returns the mode of operation in which the volume mounted as the specified drive letter is encrypted.

+int GetModeOfOperationByDriveNo (int nDosDriveNo)

+{

+ VOLUME_PROPERTIES_STRUCT prop;

+ DWORD dwResult;

+

+ memset (&prop, 0, sizeof(prop));

+ prop.driveNo = nDosDriveNo;

+

+ if (DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL))

+ {

+ return prop.mode;

+ }

+

+ return 0;

+}

+

+

+BOOL CALLBACK VolumePropertiesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+{

+ BOOL bSysEnc = (BOOL) lParam;

+ BOOL bSysEncWholeDrive = FALSE;

+ WORD lw = LOWORD (wParam);

+ int i = 0;

+

+ switch (msg)

+ {

+ case WM_INITDIALOG:

+ {

+ VOLUME_PROPERTIES_STRUCT prop;

+ DWORD dwResult;

+

+ LVCOLUMNW lvCol;

+ HWND list = GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES_LIST);

+ char szTmp[1024];

+ wchar_t sw[1024];

+ wchar_t *s;

+

+ if (bSysEnc)

+ {

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ bSysEncWholeDrive = WholeSysDriveEncryption(FALSE);

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ return 0;

+ }

+

+ if (!BootEncStatus.DriveEncrypted && !BootEncStatus.DriveMounted)

+ return 0;

+ }

+ else

+ {

+ switch (LOWORD (GetSelectedLong (GetDlgItem (GetParent(hwndDlg), IDC_DRIVELIST))))

+ {

+ case TC_MLIST_ITEM_FREE:

+

+ // No mounted volume

+ EndDialog (hwndDlg, IDOK);

+ return 0;

+

+ case TC_MLIST_ITEM_NONSYS_VOL:

+ // NOP

+ break;

+

+ case TC_MLIST_ITEM_SYS_DRIVE:

+ // Encrypted system drive

+ bSysEnc = TRUE;

+ bSysEncWholeDrive = TRUE;

+ break;

+

+ case TC_MLIST_ITEM_SYS_PARTITION:

+ // Encrypted system partition

+ bSysEnc = TRUE;

+ bSysEncWholeDrive = FALSE;

+ break;

+ }

+ }

+

+ LocalizeDialog (hwndDlg, "IDD_VOLUME_PROPERTIES");

+

+ SendMessage (list,LVM_SETEXTENDEDLISTVIEWSTYLE, 0,

+ LVS_EX_FULLROWSELECT

+ |LVS_EX_HEADERDRAGDROP

+ |LVS_EX_LABELTIP

+ );

+

+ memset (&lvCol,0,sizeof(lvCol));

+ lvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

+ lvCol.pszText = GetString ("VALUE");

+ lvCol.cx = CompensateXDPI (208);

+ lvCol.fmt = LVCFMT_LEFT;

+ SendMessage (list,LVM_INSERTCOLUMNW,0,(LPARAM)&lvCol);

+

+ lvCol.pszText = GetString ("PROPERTY");

+ lvCol.cx = CompensateXDPI (192);

+ lvCol.fmt = LVCFMT_LEFT;

+ SendMessage (list,LVM_INSERTCOLUMNW,0,(LPARAM)&lvCol);

+

+ memset (&prop, 0, sizeof(prop));

+ prop.driveNo = HIWORD (GetSelectedLong (GetDlgItem (GetParent(hwndDlg), IDC_DRIVELIST))) - 'A';

+

+ if (bSysEnc)

+ {

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ if (!BootEncStatus.DriveEncrypted && !BootEncStatus.DriveMounted)

+ return 0;

+

+ BootEncObj->GetVolumeProperties (&prop);

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ return 0;

+ }

+ }

+ else

+ {

+ if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL) || dwResult == 0)

+ return 0;

+ }

+

+ // Location

+ ListItemAddW (list, i, GetString ("LOCATION"));

+ if (bSysEnc)

+ ListSubItemSetW (list, i++, 1, GetString (bSysEncWholeDrive ? "SYSTEM_DRIVE" : IsHiddenOSRunning() ? "HIDDEN_SYSTEM_PARTITION" : "SYSTEM_PARTITION"));

+ else

+ ListSubItemSetW (list, i++, 1, (wchar_t *) (prop.wszVolume[1] != L'?' ? prop.wszVolume : prop.wszVolume + 4));

+

+ // Size

+ ListItemAddW (list, i, GetString ("SIZE"));

+ swprintf (sw, L"%I64u %s", prop.diskLength, GetString ("BYTES"));

+ ListSubItemSetW (list, i++, 1, sw);

+

+ // Type

+ ListItemAddW (list, i, GetString ("TYPE"));

+ if (bSysEnc)

+ ListSubItemSetW (list, i++, 1, GetString (IsHiddenOSRunning() ? "TYPE_HIDDEN_SYSTEM_ADJECTIVE" : "SYSTEM_VOLUME_TYPE_ADJECTIVE"));

+ else

+ {

+ ListSubItemSetW (list, i++, 1,

+ prop.hiddenVolume ? GetString ("HIDDEN") :

+ (prop.hiddenVolProtection != HIDVOL_PROT_STATUS_NONE ? GetString ("OUTER") : GetString ("NORMAL")));

+ }

+

+ if (!bSysEnc)

+ {

+ // Write protection

+ ListItemAddW (list, i, GetString ("READ_ONLY"));

+

+ if (prop.readOnly || prop.hiddenVolProtection == HIDVOL_PROT_STATUS_ACTION_TAKEN)

+ s = GetString ("UISTR_YES");

+ else

+ s = GetString ("UISTR_NO");

+

+ ListSubItemSetW (list, i++, 1, s);

+

+ // Hidden Volume Protection

+ ListItemAddW (list, i, GetString ("HIDDEN_VOL_PROTECTION"));

+ if (prop.hiddenVolume)

+ s = GetString ("NOT_APPLICABLE_OR_NOT_AVAILABLE");

+ else if (prop.hiddenVolProtection == HIDVOL_PROT_STATUS_NONE)

+ s = GetString ("UISTR_NO");

+ else if (prop.hiddenVolProtection == HIDVOL_PROT_STATUS_ACTIVE)

+ s = GetString ("UISTR_YES");

+ else if (prop.hiddenVolProtection == HIDVOL_PROT_STATUS_ACTION_TAKEN)

+ s = GetString ("HID_VOL_DAMAGE_PREVENTED");

+

+ ListSubItemSetW (list, i++, 1, s);

+ }

+

+ // Encryption algorithm

+ ListItemAddW (list, i, GetString ("ENCRYPTION_ALGORITHM"));

+

+ if (prop.ea == 0 || prop.ea > EAGetCount ())

+ {

+ ListSubItemSet (list, i, 1, "?");

+ return 1;

+ }

+

+ EAGetName (szTmp, prop.ea);

+ ListSubItemSet (list, i++, 1, szTmp);

+

+ // Key size(s)

+ {

+ char name[128];

+ int size = EAGetKeySize (prop.ea);

+ EAGetName (name, prop.ea);

+

+ if (strcmp (name, "Triple DES") == 0) /* Deprecated/legacy */

+ size -= 3; // Compensate for parity bytes

+

+ // Primary key

+ ListItemAddW (list, i, GetString ("KEY_SIZE"));

+ wsprintfW (sw, L"%d %s", size * 8, GetString ("BITS"));

+ ListSubItemSetW (list, i++, 1, sw);

+

+ if (strcmp (EAGetModeName (prop.ea, prop.mode, TRUE), "XTS") == 0)

+ {

+ // Secondary key (XTS)

+

+ ListItemAddW (list, i, GetString ("SECONDARY_KEY_SIZE_XTS"));

+ ListSubItemSetW (list, i++, 1, sw);

+ }

+ else if (strcmp (EAGetModeName (prop.ea, prop.mode, TRUE), "LRW") == 0)

+ {

+ // Tweak key (LRW)

+

+ ListItemAddW (list, i, GetString ("SECONDARY_KEY_SIZE_LRW"));

+ swprintf (sw, L"%d %s", CipherGetBlockSize (EAGetFirstCipher(prop.ea))*8, GetString ("BITS"));

+ ListSubItemSetW (list, i++, 1, sw);

+ }

+ }

+

+ // Block size

+ ListItemAddW (list, i, GetString ("BLOCK_SIZE"));

+ if (EAGetFirstMode (prop.ea) == INNER_CBC)

+ {

+ // Cascaded ciphers with non-equal block sizes (deprecated/legacy)

+ wchar_t tmpstr[64];

+ int i = EAGetLastCipher(prop.ea);

+

+ swprintf (sw, L"%d", CipherGetBlockSize(i)*8);

+

+ while (i = EAGetPreviousCipher(prop.ea, i))

+ {

+ swprintf (tmpstr, L"/%d", CipherGetBlockSize(i)*8);

+ wcscat (sw, tmpstr);

+ }

+ wcscat (sw, L" ");

+ }

+ else

+ {

+ swprintf (sw, L"%d ", CipherGetBlockSize (EAGetFirstCipher(prop.ea))*8);

+ }

+ wcscat (sw, GetString ("BITS"));

+ ListSubItemSetW (list, i++, 1, sw);

+

+ // Mode

+ ListItemAddW (list, i, GetString ("MODE_OF_OPERATION"));

+ ListSubItemSet (list, i++, 1, EAGetModeName (prop.ea, prop.mode, TRUE));

+

+ // PKCS 5 PRF

+ ListItemAddW (list, i, GetString ("PKCS5_PRF"));

+ ListSubItemSet (list, i++, 1, get_pkcs5_prf_name (prop.pkcs5));

+

+#if 0

+ // PCKS 5 iterations

+ ListItemAddW (list, i, GetString ("PKCS5_ITERATIONS"));

+ sprintf (szTmp, "%d", prop.pkcs5Iterations);

+ ListSubItemSet (list, i++, 1, szTmp);

+#endif

+

+#if 0

+ {

+ // Legacy

+

+ FILETIME ft, curFt;

+ LARGE_INTEGER ft64, curFt64;

+ SYSTEMTIME st;

+ wchar_t date[128];

+ memset (date, 0, sizeof (date));

+

+ // Volume date

+ ListItemAddW (list, i, GetString ("VOLUME_CREATE_DATE"));

+ *(unsigned __int64 *)(&ft) = prop.volumeCreationTime;

+ FileTimeToSystemTime (&ft, &st);

+ GetDateFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);

+ swprintf (date, L"%s ", sw);

+ GetTimeFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);

+ wcscat (date, sw);

+ ListSubItemSetW (list, i++, 1, date);

+

+ // Header date

+ ListItemAddW (list, i, GetString ("VOLUME_HEADER_DATE"));

+ *(unsigned __int64 *)(&ft) = prop.headerCreationTime;

+ FileTimeToSystemTime (&ft, &st);

+ GetDateFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);

+ swprintf (date, L"%s ", sw);

+ GetTimeFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);

+ wcscat (date, sw);

+

+ GetLocalTime (&st);

+ SystemTimeToFileTime (&st, &curFt);

+ curFt64.HighPart = curFt.dwHighDateTime;

+ curFt64.LowPart = curFt.dwLowDateTime;

+ ft64.HighPart = ft.dwHighDateTime;

+ ft64.LowPart = ft.dwLowDateTime;

+ swprintf (date + wcslen (date), GetString ("VOLUME_HEADER_DAYS")

+ , (curFt64.QuadPart - ft64.QuadPart)/(24LL*3600*10000000));

+ ListSubItemSetW (list, i++, 1, date);

+ }

+#endif // 0

+

+ if (!bSysEnc || IsHiddenOSRunning())

+ {

+ // Volume format version

+ ListItemAddW (list, i, GetString ("VOLUME_FORMAT_VERSION"));

+ sprintf (szTmp, "%d", prop.volFormatVersion);

+ ListSubItemSet (list, i++, 1, szTmp);

+

+ // Backup header

+ ListItemAddW (list, i, GetString ("BACKUP_HEADER"));

+ ListSubItemSetW (list, i++, 1, GetString (prop.volFormatVersion > 1 ? "UISTR_YES" : "UISTR_NO"));

+ }

+

+ // Total data read

+ ListItemAddW (list, i, GetString ("TOTAL_DATA_READ"));

+ GetSizeString (prop.totalBytesRead, sw);

+ ListSubItemSetW (list, i++, 1, sw);

+

+ // Total data written

+ ListItemAddW (list, i, GetString ("TOTAL_DATA_WRITTEN"));

+ GetSizeString (prop.totalBytesWritten, sw);

+ ListSubItemSetW (list, i++, 1, sw);

+

+ if (bSysEnc)

+ {

+ // TrueCrypt Boot Loader version

+ ListItemAddW (list, i, GetString ("TC_BOOT_LOADER_VERSION"));

+ ListSubItemSet (list, i++, 1, (char *) GetUserFriendlyVersionString (BootEncStatus.BootLoaderVersion).c_str());

+

+ // Encrypted portion

+ ListItemAddW (list, i, GetString ("ENCRYPTED_PORTION"));

+ if (GetSysEncDeviceEncryptedPartSize (FALSE) == GetSysEncDeviceSize (FALSE))

+ ListSubItemSetW (list, i++, 1, GetString ("ENCRYPTED_PORTION_FULLY_ENCRYPTED"));

+ else if (GetSysEncDeviceEncryptedPartSize (FALSE) <= 1)

+ ListSubItemSetW (list, i++, 1, GetString ("ENCRYPTED_PORTION_NOT_ENCRYPTED"));

+ else

+ {

+

+ _snwprintf (sw,

+ sizeof sw/2,

+ GetString ("PROCESSED_PORTION_X_PERCENT"),

+ (double) GetSysEncDeviceEncryptedPartSize (FALSE) / (double) GetSysEncDeviceSize (FALSE) * 100.0);

+

+ ListSubItemSetW (list, i++, 1, sw);

+ }

+ }

+

+ return 0;

+ }

+

+ case WM_COMMAND:

+ if (lw == IDOK)

+ {

+ EndDialog (hwndDlg, lw);

+ return 1;

+ }

+ return 0;

+

+ case WM_CLOSE:

+ EndDialog (hwndDlg, lw);

+ return 1;

+ }

+

+ return 0;

+}

+

+

+BOOL CALLBACK TravelerDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+{

+ WORD lw = LOWORD (wParam);

+ static BOOL bAutoRunWarningDisplayed = FALSE;

+

+ switch (msg)

+ {

+ case WM_INITDIALOG:

+ {

+ char i;

+ int index;

+ char drive[] = { 0, ':', 0 };

+

+ LocalizeDialog (hwndDlg, "IDD_TRAVELER_DLG");

+

+ SendDlgItemMessage (hwndDlg, IDC_COPY_WIZARD, BM_SETCHECK,

+ BST_CHECKED, 0);

+

+ SendDlgItemMessage (hwndDlg, IDC_TRAVEL_OPEN_EXPLORER, BM_SETCHECK,

+ BST_CHECKED, 0);

+

+ SendDlgItemMessage (hwndDlg, IDC_AUTORUN_DISABLE, BM_SETCHECK,

+ BST_CHECKED, 0);

+

+ SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_RESETCONTENT, 0, 0);

+

+ index = SendDlgItemMessageW (hwndDlg, IDC_DRIVELIST, CB_ADDSTRING, 0, (LPARAM) GetString ("FIRST_AVAILABLE"));

+ SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_SETITEMDATA, index, (LPARAM) 0);

+

+ for (i = 'D'; i <= 'Z'; i++)

+ {

+ drive[0] = i;

+ index = SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_ADDSTRING, 0, (LPARAM) drive);

+ SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_SETITEMDATA, index, (LPARAM) i);

+ }

+

+ SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_SETCURSEL, 0, 0);

+

+ return 0;

+ }

+

+

+ case WM_COMMAND:

+

+ if (HIWORD (wParam) == BN_CLICKED

+ && (lw == IDC_AUTORUN_DISABLE || lw == IDC_AUTORUN_MOUNT || lw == IDC_AUTORUN_START ))

+ {

+ BOOL enabled = IsButtonChecked (GetDlgItem (hwndDlg, IDC_AUTORUN_MOUNT));

+

+ EnableWindow (GetDlgItem (hwndDlg, IDC_BROWSE_FILES), enabled);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_NAME), enabled);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_TRAVEL_OPEN_EXPLORER), enabled);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_TRAV_CACHE_PASSWORDS), enabled);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY), enabled);

+ EnableWindow (GetDlgItem (hwndDlg, IDC_DRIVELIST), enabled);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_TRAVELER_MOUNT), enabled);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_MOUNT_LETTER), enabled);

+ EnableWindow (GetDlgItem (hwndDlg, IDT_MOUNT_SETTINGS), enabled);

+

+ if (!bAutoRunWarningDisplayed

+ && (lw == IDC_AUTORUN_MOUNT || lw == IDC_AUTORUN_START))

+ {

+ bAutoRunWarningDisplayed = TRUE;

+ Warning ("AUTORUN_MAY_NOT_ALWAYS_WORK");

+ }

+

+ return 1;

+ }

+

+ if (lw == IDC_BROWSE_FILES)

+ {

+ char dstDir[MAX_PATH];

+ char volName[MAX_PATH] = { 0 };

+

+ GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstDir, sizeof dstDir);

+

+ if (BrowseFilesInDir (hwndDlg, "OPEN_TITLE", dstDir, volName, bHistory, FALSE, NULL))

+ SetDlgItemText (hwndDlg, IDC_VOLUME_NAME, strchr (volName, '\\') + 1);

+

+ return 1;

+ }

+

+ if (lw == IDC_BROWSE_DIRS)

+ {

+ char dstPath[MAX_PATH * 2];

+ GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstPath, sizeof dstPath);

+

+ if (BrowseDirectories (hwndDlg, "SELECT_DEST_DIR", dstPath))

+ SetDlgItemText (hwndDlg, IDC_DIRECTORY, dstPath);

+

+ return 1;

+ }

+

+ if (lw == IDCANCEL || lw == IDCLOSE)

+ {

+ EndDialog (hwndDlg, lw);

+ return 1;

+ }

+

+ if (lw == IDC_CREATE)

+ {

+

+ BOOL copyWizard, bExplore, bCacheInDriver, bAutoRun, bAutoMount, bMountReadOnly;

+ char dstDir[MAX_PATH];

+ char srcPath[MAX_PATH * 2];

+ char dstPath[MAX_PATH * 2];

+ char appDir[MAX_PATH];

+ char sysDir[MAX_PATH];

+ char volName[MAX_PATH];

+ int drive;

+

+ GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstDir, sizeof dstDir);

+ volName[0] = 0;

+ GetDlgItemText (hwndDlg, IDC_VOLUME_NAME, volName + 1, sizeof volName);

+

+ drive = SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_GETCURSEL, 0, 0);

+ drive = SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_GETITEMDATA, drive, 0);

+

+ copyWizard = IsButtonChecked (GetDlgItem (hwndDlg, IDC_COPY_WIZARD));

+ bExplore = IsButtonChecked (GetDlgItem (hwndDlg, IDC_TRAVEL_OPEN_EXPLORER));

+ bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_TRAV_CACHE_PASSWORDS));

+ bMountReadOnly = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY));

+ bAutoRun = !IsButtonChecked (GetDlgItem (hwndDlg, IDC_AUTORUN_DISABLE));

+ bAutoMount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_AUTORUN_MOUNT));

+

+ if (dstDir[0] == 0)

+ {

+ SetFocus (GetDlgItem (hwndDlg, IDC_DIRECTORY));

+ MessageBoxW (hwndDlg, GetString ("NO_PATH_SELECTED"), lpszTitle, MB_ICONEXCLAMATION);

+ return 1;

+ }

+

+

+ if (bAutoMount && volName[1] == 0)

+ {

+ SetFocus (GetDlgItem (hwndDlg, IDC_VOLUME_NAME));

+ MessageBoxW (hwndDlg, GetString ("NO_FILE_SELECTED"), lpszTitle, MB_ICONEXCLAMATION);

+ return 1;

+ }

+

+ if (volName[1] != 0)

+ {

+ volName[0] = '"';

+ strcat (volName, "\"");

+ }

+

+ GetModuleFileName (NULL, appDir, sizeof (appDir));

+ strrchr (appDir, '\\')[0] = 0;

+

+ WaitCursor ();

+ GetSystemDirectory (sysDir, sizeof (sysDir));

+

+ sprintf (dstPath, "%s\\TrueCrypt", dstDir);

+ CreateDirectory (dstPath, NULL);

+

+ // Main app

+ sprintf (srcPath, "%s\\TrueCrypt.exe", appDir);

+ sprintf (dstPath, "%s\\TrueCrypt\\TrueCrypt.exe", dstDir);

+ if (!TCCopyFile (srcPath, dstPath))

+ {

+ handleWin32Error (hwndDlg);

+ goto stop;

+ }

+

+ // Wizard

+ if (copyWizard)

+ {

+ sprintf (srcPath, "%s\\TrueCrypt Format.exe", appDir);

+ sprintf (dstPath, "%s\\TrueCrypt\\TrueCrypt Format.exe", dstDir);

+ if (!TCCopyFile (srcPath, dstPath))

+ {

+ handleWin32Error (hwndDlg);

+ goto stop;

+ }

+ }

+

+ // Driver

+ sprintf (srcPath, "%s\\truecrypt.sys", appDir);

+ sprintf (dstPath, "%s\\TrueCrypt\\truecrypt.sys", dstDir);

+ if (!TCCopyFile (srcPath, dstPath))

+ {

+ handleWin32Error (hwndDlg);

+ goto stop;

+ }

+

+ // Driver x64

+ sprintf (srcPath, "%s\\truecrypt-x64.sys", appDir);

+ sprintf (dstPath, "%s\\TrueCrypt\\truecrypt-x64.sys", dstDir);

+ if (!TCCopyFile (srcPath, dstPath))

+ {

+ handleWin32Error (hwndDlg);

+ goto stop;

+ }

+

+ if (GetPreferredLangId () && strcmp (GetPreferredLangId (), "en") != 0)

+ {

+ // Language pack

+ sprintf (srcPath, "%s\\Language.%s.xml", appDir, GetPreferredLangId ());

+ sprintf (dstPath, "%s\\TrueCrypt\\Language.%s.xml", dstDir, GetPreferredLangId ());

+ TCCopyFile (srcPath, dstPath);

+ }

+

+ // AutoRun

+ sprintf (dstPath, "%s\\autorun.inf", dstDir);

+ DeleteFile (dstPath);

+ if (bAutoRun)

+ {

+ FILE *af;

+ char autoMount[100];

+ char driveLetter[] = { ' ', '/', 'l', (char) drive, 0 };

+

+ af = fopen (dstPath, "w,ccs=UNICODE");

+

+ if (af == NULL)

+ {

+ MessageBoxW (hwndDlg, GetString ("CANT_CREATE_AUTORUN"), lpszTitle, MB_ICONERROR);

+ goto stop;

+ }

+

+ sprintf (autoMount, "TrueCrypt\\TrueCrypt.exe /q background%s%s%s%s /m rm /v %s",

+ drive > 0 ? driveLetter : "",

+ bExplore ? " /e" : "",

+ bCacheInDriver ? " /c y" : "",

+ bMountReadOnly ? " /m ro" : "",

+ volName);

+

+ fwprintf (af, L"[autorun]\nlabel=%s\nicon=TrueCrypt\\TrueCrypt.exe\n", GetString ("TC_TRAVELER_DISK"));

+ fwprintf (af, L"action=%s\n", bAutoMount ? GetString ("MOUNT_TC_VOLUME") : GetString ("IDC_PREF_LOGON_START"));

+ fwprintf (af, L"open=%hs\n", bAutoMount ? autoMount : "TrueCrypt\\TrueCrypt.exe");

+ fwprintf (af, L"shell\\start=%s\nshell\\start\\command=TrueCrypt\\TrueCrypt.exe\n", GetString ("IDC_PREF_LOGON_START"));

+ fwprintf (af, L"shell\\dismount=%s\nshell\\dismount\\command=TrueCrypt\\TrueCrypt.exe /q /d\n", GetString ("DISMOUNT_ALL_TC_VOLUMES"));

+

+ CheckFileStreamWriteErrors (af, dstPath);

+ fclose (af);

+ }

+ MessageBoxW (hwndDlg, GetString ("TRAVELER_DISK_CREATED"), lpszTitle, MB_ICONINFORMATION);

+

+stop:

+ NormalCursor ();

+ return 1;

+ }

+ return 0;

+ }

+

+ return 0;

+}

+

+void BuildTree (HWND hTree)

+{

+ HIMAGELIST hList;

+ HBITMAP hBitmap, hBitmapMask;

+ LVCOLUMNW lvCol;

+

+ ListView_DeleteColumn (hTree,0);

+ ListView_DeleteColumn (hTree,0);

+ ListView_DeleteColumn (hTree,0);

+ ListView_DeleteColumn (hTree,0);

+ ListView_DeleteColumn (hTree,0);

+ ListView_DeleteColumn (hTree,0);

+

+ SendMessage(hTree,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

+ LVS_EX_FULLROWSELECT

+ |LVS_EX_HEADERDRAGDROP

+ );

+

+ memset(&lvCol,0,sizeof(lvCol));

+

+ lvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

+ lvCol.pszText = GetString ("DRIVE");

+ lvCol.cx = CompensateXDPI (38);

+ lvCol.fmt = LVCFMT_COL_HAS_IMAGES|LVCFMT_LEFT ;

+ SendMessage (hTree,LVM_INSERTCOLUMNW,0,(LPARAM)&lvCol);

+

+ lvCol.pszText = GetString ("VOLUME");

+ lvCol.cx = CompensateXDPI (253);

+ lvCol.fmt = LVCFMT_LEFT;

+ SendMessage (hTree,LVM_INSERTCOLUMNW,1,(LPARAM)&lvCol);

+ LastDriveListVolumeColumnWidth = ListView_GetColumnWidth (hTree, 1);

+

+ lvCol.pszText = GetString ("SIZE");

+ lvCol.cx = CompensateXDPI (55);

+ lvCol.fmt = LVCFMT_RIGHT;

+ SendMessage (hTree,LVM_INSERTCOLUMNW,2,(LPARAM)&lvCol);

+

+ lvCol.pszText = GetString ("ENCRYPTION_ALGORITHM_LV");

+ lvCol.cx = CompensateXDPI (121);

+ lvCol.fmt = LVCFMT_LEFT;

+ SendMessage (hTree,LVM_INSERTCOLUMNW,3,(LPARAM)&lvCol);

+

+ lvCol.pszText = GetString ("TYPE");

+ lvCol.cx = CompensateXDPI (52);

+ lvCol.fmt = LVCFMT_LEFT;

+ SendMessage (hTree,LVM_INSERTCOLUMNW,4,(LPARAM)&lvCol);

+

+ // Regular drive icon

+

+ hBitmap = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_DRIVEICON));

+ if (hBitmap == NULL)

+ return;

+ hBitmapMask = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_DRIVEICON_MASK));

+

+ hList = ImageList_Create (16, 12, ILC_COLOR8|ILC_MASK, 2, 2);

+ if (ImageList_Add (hList, hBitmap, hBitmapMask) == -1)

+ {

+ DeleteObject (hBitmap);

+ DeleteObject (hBitmapMask);

+ return;

+ }

+ else

+ {

+ DeleteObject (hBitmap);

+ DeleteObject (hBitmapMask);

+ }

+

+ // System drive icon

+

+ hBitmap = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_SYS_DRIVEICON));

+ if (hBitmap == NULL)

+ return;

+ hBitmapMask = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_SYS_DRIVEICON_MASK));

+

+ if (ImageList_Add (hList, hBitmap, hBitmapMask) == -1)

+ {

+ DeleteObject (hBitmap);

+ DeleteObject (hBitmapMask);

+ return;

+ }

+ else

+ {

+ DeleteObject (hBitmap);

+ DeleteObject (hBitmapMask);

+ }

+

+ ListView_SetImageList (hTree, hList, LVSIL_NORMAL);

+ ListView_SetImageList (hTree, hList, LVSIL_SMALL);

+

+ LoadDriveLetters (hTree, 0);

+}

+

+LPARAM GetSelectedLong (HWND hTree)

+{

+ int hItem = ListView_GetSelectionMark (hTree);

+ LVITEM item;

+

+ if (nSelectedDriveIndex >= 0)

+ hItem = nSelectedDriveIndex;

+

+ memset(&item, 0, sizeof(LVITEM));

+ item.mask = LVIF_PARAM;

+ item.iItem = hItem;

+

+ if (ListView_GetItem (hTree, &item) == FALSE)

+ return MAKELONG (0xffff, 0xffff);

+ else

+ return item.lParam;

+}

+

+LPARAM GetItemLong (HWND hTree, int itemNo)

+{

+ LVITEM item;

+

+ memset(&item, 0, sizeof(LVITEM));

+ item.mask = LVIF_PARAM;

+ item.iItem = itemNo;

+

+ if (ListView_GetItem (hTree, &item) == FALSE)

+ return MAKELONG (0xffff, 0xffff);

+ else

+ return item.lParam;

+}

+

+static int AskVolumePassword (HWND hwndDlg, Password *password, char *titleStringId, BOOL enableMountOptions)

+{

+ int result;

+

+ PasswordDialogTitleStringId = titleStringId;

+ PasswordDialogDisableMountOptions = !enableMountOptions;

+

+ result = DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_PASSWORD_DLG), hwndDlg,

+ (DLGPROC) PasswordDlgProc, (LPARAM) password);

+

+ if (result != IDOK)

+ {

+ password->Length = 0;

+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

+ }

+

+ return result == IDOK;

+}

+

+// GUI actions

+

+static BOOL Mount (HWND hwndDlg, int nDosDriveNo, char *szFileName)

+{

+ BOOL status = FALSE;

+ char fileName[MAX_PATH];

+ int mounted = 0, modeOfOperation;

+

+ bPrebootPasswordDlgMode = mountOptions.PartitionInInactiveSysEncScope;

+

+ if (nDosDriveNo == 0)

+ nDosDriveNo = HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) - 'A';

+

+ if (!MultipleMountOperationInProgress)

+ VolumePassword.Length = 0;

+

+ if (szFileName == NULL)

+ {

+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), fileName, sizeof (fileName));

+ szFileName = fileName;

+ }

+

+ if (strlen(szFileName) == 0)

+ {

+ status = FALSE;

+ goto ret;

+ }

+

+ if (IsMountedVolume (szFileName))

+ {

+ Warning ("VOL_ALREADY_MOUNTED");

+ status = FALSE;

+ goto ret;

+ }

+

+ if (!VolumePathExists (szFileName))

+ {

+ if (!MultipleMountOperationInProgress)

+ handleWin32Error (hwndDlg);

+

+ status = FALSE;

+ goto ret;

+ }

+

+ ResetWrongPwdRetryCount ();

+

+ // First try cached passwords and if they fail ask user for a new one

+ WaitCursor ();

+

+ mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, NULL, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE);

+

+ // If keyfiles are enabled, test empty password first

+ if (!mounted && KeyFilesEnable && FirstKeyFile)

+ {

+ Password emptyPassword;

+ emptyPassword.Length = 0;

+

+ KeyFilesApply (&emptyPassword, FirstKeyFile);

+ mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &emptyPassword, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE);

+

+ burn (&emptyPassword, sizeof (emptyPassword));

+ }

+

+ // Test password and/or keyfiles used for the previous volume

+ if (!mounted && MultipleMountOperationInProgress && VolumePassword.Length != 0)

+ mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &VolumePassword, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE);

+

+ NormalCursor ();

+

+ if (mounted)

+ {

+ // Check for deprecated CBC mode

+ modeOfOperation = GetModeOfOperationByDriveNo (nDosDriveNo);

+ if (modeOfOperation == CBC || modeOfOperation == OUTER_CBC)

+ Warning("WARN_CBC_MODE");

+

+ // Check for deprecated 64-bit-block ciphers

+ if (GetCipherBlockSizeByDriveNo (nDosDriveNo) == 64)

+ Warning("WARN_64_BIT_BLOCK_CIPHER");

+

+ // Check for problematic file extensions (exe, dll, sys)

+ if (CheckFileExtension(szFileName))

+ Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING");

+ }

+

+ while (mounted == 0)

+ {

+ if (CmdVolumePassword.Length > 0)

+ {

+ VolumePassword = CmdVolumePassword;

+ }

+ else if (!Silent)

+ {

+ strcpy (PasswordDlgVolume, szFileName);

+

+ if (!AskVolumePassword (hwndDlg, &VolumePassword, NULL, TRUE))

+ goto ret;

+ }

+

+ WaitCursor ();

+

+ if (KeyFilesEnable)

+ KeyFilesApply (&VolumePassword, FirstKeyFile);

+

+ mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &VolumePassword, bCacheInDriver, bForceMount, &mountOptions, Silent, !Silent);

+ NormalCursor ();

+

+ // Check for deprecated CBC mode

+ modeOfOperation = GetModeOfOperationByDriveNo (nDosDriveNo);

+ if (modeOfOperation == CBC || modeOfOperation == OUTER_CBC)

+ Warning("WARN_CBC_MODE");

+

+ // Check for deprecated 64-bit-block ciphers

+ if (GetCipherBlockSizeByDriveNo (nDosDriveNo) == 64)

+ Warning("WARN_64_BIT_BLOCK_CIPHER");

+

+ // Check for legacy non-ASCII passwords

+ if (mounted > 0 && !KeyFilesEnable && !CheckPasswordCharEncoding (NULL, &VolumePassword))

+ Warning ("UNSUPPORTED_CHARS_IN_PWD_RECOM");

+

+ // Check for problematic file extensions (exe, dll, sys)

+ if (mounted > 0 && CheckFileExtension (szFileName))

+ Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING");

+

+ if (!MultipleMountOperationInProgress)

+ burn (&VolumePassword, sizeof (VolumePassword));

+

+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

+

+ if (CmdVolumePassword.Length > 0 || Silent)

+ break;

+ }

+

+ if (mounted > 0)

+ {

+ status = TRUE;

+

+ if (bBeep)

+ MessageBeep (0xFFFFFFFF);

+

+ RefreshMainDlg(hwndDlg);

+

+ if (bExplore)

+ {

+ WaitCursor();

+ OpenVolumeExplorerWindow (nDosDriveNo);

+ NormalCursor();

+ }

+

+ if (mountOptions.ProtectHiddenVolume)

+ Info ("HIDVOL_PROT_WARN_AFTER_MOUNT");

+ }

+

+ret:

+ if (!MultipleMountOperationInProgress)

+ burn (&VolumePassword, sizeof (VolumePassword));

+

+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

+

+ RestoreDefaultKeyFilesParam ();

+

+ if (UsePreferences)

+ bCacheInDriver = bCacheInDriverDefault;

+

+ if (status && CloseSecurityTokenSessionsAfterMount && !MultipleMountOperationInProgress)

+ SecurityToken::CloseAllSessions();

+

+ return status;

+}

+

+

+static BOOL Dismount (HWND hwndDlg, int nDosDriveNo)

+{

+ BOOL status = FALSE;

+ WaitCursor ();

+

+ if (nDosDriveNo == 0)

+ nDosDriveNo = (char) (HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) - 'A');

+

+ if (bCloseDismountedWindows)

+ {

+ CloseVolumeExplorerWindows (hwndDlg, nDosDriveNo);

+ }

+

+ if (UnmountVolume (hwndDlg, nDosDriveNo, bForceUnmount))

+ {

+ status = TRUE;

+

+ if (bBeep)

+ MessageBeep (0xFFFFFFFF);

+ RefreshMainDlg (hwndDlg);

+

+ if (nCurrentOS == WIN_2000 && RemoteSession && !IsAdmin ())

+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), 0);

+ }

+

+ NormalCursor ();

+ return status;

+}

+

+static BOOL DismountAll (HWND hwndDlg, BOOL forceUnmount, BOOL interact, int dismountMaxRetries, int dismountAutoRetryDelay)

+{

+ BOOL status = TRUE;

+ MOUNT_LIST_STRUCT mountList;

+ DWORD dwResult;

+ UNMOUNT_STRUCT unmount;

+ BOOL bResult;

+ unsigned __int32 prevMountedDrives = 0;

+ int i;

+

+retry:

+ WaitCursor();

+

+ DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mountList, sizeof (mountList), &mountList, sizeof (mountList), &dwResult, NULL);

+

+ if (mountList.ulMountedDrives == 0)

+ {

+ NormalCursor();

+ return TRUE;

+ }

+

+ BroadcastDeviceChange (DBT_DEVICEREMOVEPENDING, 0, mountList.ulMountedDrives);

+

+ prevMountedDrives = mountList.ulMountedDrives;

+

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

+ {

+ if (mountList.ulMountedDrives & (1 << i))

+ {

+ if (bCloseDismountedWindows)

+ CloseVolumeExplorerWindows (hwndDlg, i);

+ }

+ }

+

+ unmount.nDosDriveNo = 0;

+ unmount.ignoreOpenFiles = forceUnmount;

+

+ do

+ {

+ bResult = DeviceIoControl (hDriver, TC_IOCTL_DISMOUNT_ALL_VOLUMES, &unmount,

+ sizeof (unmount), &unmount, sizeof (unmount), &dwResult, NULL);

+

+ if (bResult == FALSE)

+ {

+ NormalCursor();

+ handleWin32Error (hwndDlg);

+ return FALSE;

+ }

+

+ if (unmount.nReturnCode == ERR_SUCCESS

+ && unmount.HiddenVolumeProtectionTriggered

+ && !VolumeNotificationsList.bHidVolDamagePrevReported [unmount.nDosDriveNo])

+ {

+ wchar_t msg[4096];

+

+ VolumeNotificationsList.bHidVolDamagePrevReported [unmount.nDosDriveNo] = TRUE;

+ swprintf (msg, GetString ("DAMAGE_TO_HIDDEN_VOLUME_PREVENTED"), unmount.nDosDriveNo + 'A');

+ SetForegroundWindow (hwndDlg);

+ MessageBoxW (hwndDlg, msg, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

+

+ unmount.HiddenVolumeProtectionTriggered = FALSE;

+ continue;

+ }

+

+ if (unmount.nReturnCode == ERR_FILES_OPEN)

+ Sleep (dismountAutoRetryDelay);

+ else

+ break;

+

+ } while (--dismountMaxRetries > 0);

+

+ memset (&mountList, 0, sizeof (mountList));

+ DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mountList, sizeof (mountList), &mountList, sizeof (mountList), &dwResult, NULL);

+ BroadcastDeviceChange (DBT_DEVICEREMOVECOMPLETE, 0, prevMountedDrives & ~mountList.ulMountedDrives);

+

+ RefreshMainDlg (hwndDlg);

+

+ if (nCurrentOS == WIN_2000 && RemoteSession && !IsAdmin ())

+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), 0);

+

+ NormalCursor();

+

+ if (unmount.nReturnCode != 0)

+ {

+ if (forceUnmount)

+ status = FALSE;

+

+ if (unmount.nReturnCode == ERR_FILES_OPEN)

+ {

+ if (interact && IDYES == AskWarnYesNoTopmost ("UNMOUNTALL_LOCK_FAILED"))

+ {

+ forceUnmount = TRUE;

+ goto retry;

+ }

+

+ if (IsOSAtLeast (WIN_7))

+ {

+ // Undo SHCNE_DRIVEREMOVED

+ DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, NULL, 0, &mountList, sizeof (mountList), &dwResult, NULL);

+

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

+ {

+ if (mountList.ulMountedDrives & (1 << i))

+ {

+ char root[] = { (char) i + 'A', ':', '\\', 0 };

+ SHChangeNotify (SHCNE_DRIVEADD, SHCNF_PATH, root, NULL);

+ }

+ }

+ }

+

+ return FALSE;

+ }

+

+ if (interact)

+ MessageBoxW (hwndDlg, GetString ("UNMOUNT_FAILED"), lpszTitle, MB_ICONERROR);

+ }

+ else

+ {

+ if (bBeep)

+ MessageBeep (0xFFFFFFFF);

+ }

+

+ return status;

+}

+

+static BOOL MountAllDevices (HWND hwndDlg, BOOL bPasswordPrompt)

+{

+ HWND driveList = GetDlgItem (hwndDlg, IDC_DRIVELIST);

+ int selDrive = ListView_GetSelectionMark (driveList);

+ BOOL shared = FALSE, status = FALSE, b64BitBlockCipher = FALSE, bCBCMode = FALSE, bHeaderBakRetry = FALSE;

+ int mountedVolCount = 0, modeOfOperation;

+ vector <HostDevice> devices;

+

+ VolumePassword.Length = 0;

+ mountOptions = defaultMountOptions;

+ bPrebootPasswordDlgMode = FALSE;

+

+ if (selDrive == -1)

+ selDrive = 0;

+

+ ResetWrongPwdRetryCount ();

+

+ MultipleMountOperationInProgress = TRUE;

+

+ do

+ {

+ if (!bHeaderBakRetry)

+ {

+ if (!CmdVolumePasswordValid && bPasswordPrompt)

+ {

+ PasswordDlgVolume[0] = '\0';

+ if (!AskVolumePassword (hwndDlg, &VolumePassword, NULL, TRUE))

+ goto ret;

+ }

+ else if (CmdVolumePasswordValid)

+ {

+ bPasswordPrompt = FALSE;

+ VolumePassword = CmdVolumePassword;

+ }

+

+ WaitCursor();

+

+ if (FirstCmdKeyFile)

+ KeyFilesApply (&VolumePassword, FirstCmdKeyFile);

+ else if (KeyFilesEnable)

+ KeyFilesApply (&VolumePassword, FirstKeyFile);

+

+ }

+

+ if (devices.empty())

+ devices = GetAvailableHostDevices (true, false, true, true);

+ foreach (const HostDevice &drive, devices)

+ {

+ vector <HostDevice> partitions = drive.Partitions;

+ partitions.insert (partitions.begin(), drive);

+

+ foreach (const HostDevice &device, partitions)

+ {

+ char szFileName[TC_MAX_PATH];

+ strcpy_s (szFileName, sizeof (szFileName), device.Path.c_str());

+ BOOL mounted = IsMountedVolume (szFileName);

+

+ // Skip other partitions of the disk if partition0 (whole disk) is mounted

+ if (!device.IsPartition && mounted)

+ break;

+

+ if (device.Floppy)

+ break;

+

+ if (device.HasUnencryptedFilesystem && !mountOptions.UseBackupHeader && !bHeaderBakRetry)

+ continue;

+

+ if (!mounted)

+ {

+ int nDosDriveNo;

+

+ while (LOWORD (GetItemLong (driveList, selDrive)) != 0xffff)

+ {

+ if(LOWORD (GetItemLong (driveList, selDrive)) != TC_MLIST_ITEM_FREE)

+ {

+ selDrive++;

+ continue;

+ }

+ nDosDriveNo = HIWORD(GetItemLong (driveList, selDrive)) - 'A';

+ break;

+ }

+

+ if (LOWORD (GetItemLong (driveList, selDrive)) == 0xffff)

+ goto ret;

+

+ // First try user password then cached passwords

+ if ((mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &VolumePassword, bCacheInDriver, bForceMount, &mountOptions, TRUE, FALSE)) > 0

+ || (mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, NULL, bCacheInDriver, bForceMount, &mountOptions, TRUE, FALSE)) > 0)

+ {

+ // A volume has been successfully mounted

+

+ ResetWrongPwdRetryCount ();

+

+ if (mounted == 2)

+ shared = TRUE;

+

+ LoadDriveLetters (driveList, (HIWORD (GetItemLong (GetDlgItem (hwndDlg, IDC_DRIVELIST), selDrive))));

+ selDrive++;

+

+ if (bExplore)

+ {

+ WaitCursor();

+ OpenVolumeExplorerWindow (nDosDriveNo);

+ NormalCursor();

+ }

+

+ if (bBeep)

+ MessageBeep (0xFFFFFFFF);

+

+ status = TRUE;

+

+ // Check for deprecated CBC mode

+ modeOfOperation = GetModeOfOperationByDriveNo (nDosDriveNo);

+ bCBCMode = (modeOfOperation == CBC || modeOfOperation == OUTER_CBC);

+

+ if (GetCipherBlockSizeByDriveNo(nDosDriveNo) == 64)

+ b64BitBlockCipher = TRUE;

+

+ mountedVolCount++;

+

+ // Skip other partitions of the disk if partition0 (whole disk) has been mounted

+ if (!device.IsPartition)

+ break;

+ }

+ }

+ }

+ }

+

+ if (mountedVolCount < 1)

+ {

+ // Failed to mount any volume

+

+ IncreaseWrongPwdRetryCount (1);

+

+ if (WrongPwdRetryCountOverLimit ()

+ && !mountOptions.UseBackupHeader

+ && !bHeaderBakRetry)

+ {

+ // Retry using embedded header backup (if any)

+ mountOptions.UseBackupHeader = TRUE;

+ bHeaderBakRetry = TRUE;

+ }

+ else if (bHeaderBakRetry)

+ {

+ mountOptions.UseBackupHeader = defaultMountOptions.UseBackupHeader;

+ bHeaderBakRetry = FALSE;

+ }

+

+ if (!Silent && !bHeaderBakRetry)

+ {

+ WCHAR szTmp[4096];

+

+ swprintf (szTmp, GetString (KeyFilesEnable || FirstCmdKeyFile ? "PASSWORD_OR_KEYFILE_WRONG_AUTOMOUNT" : "PASSWORD_WRONG_AUTOMOUNT"));

+ if (CheckCapsLock (hwndDlg, TRUE))

+ wcscat (szTmp, GetString ("PASSWORD_WRONG_CAPSLOCK_ON"));

+

+ MessageBoxW (hwndDlg, szTmp, lpszTitle, MB_ICONWARNING);

+ }

+ }

+ else if (bHeaderBakRetry)

+ {

+ // We have successfully mounted a volume using the header backup embedded in the volume (the header is damaged)

+ mountOptions.UseBackupHeader = defaultMountOptions.UseBackupHeader;

+ bHeaderBakRetry = FALSE;

+

+ if (!Silent)

+ Warning ("HEADER_DAMAGED_AUTO_USED_HEADER_BAK");

+ }

+

+ if (!bHeaderBakRetry)

+ {

+ burn (&VolumePassword, sizeof (VolumePassword));

+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

+ }

+

+ } while (bPasswordPrompt && mountedVolCount < 1);

+

+ /* One or more volumes successfully mounted */

+

+ ResetWrongPwdRetryCount ();

+

+ if (shared)

+ Warning ("DEVICE_IN_USE_INFO");

+

+ if (mountOptions.ProtectHiddenVolume)

+ {

+ if (mountedVolCount > 1)

+ Info ("HIDVOL_PROT_WARN_AFTER_MOUNT_PLURAL");

+ else if (mountedVolCount == 1)

+ Info ("HIDVOL_PROT_WARN_AFTER_MOUNT");

+ }

+

+ // Check for deprecated CBC mode

+ if (bCBCMode)

+ Warning("WARN_CBC_MODE");

+

+ // Check for deprecated 64-bit-block ciphers

+ if (b64BitBlockCipher)

+ Warning("WARN_64_BIT_BLOCK_CIPHER");

+

+ // Check for legacy non-ASCII passwords

+ if (!KeyFilesEnable

+ && !FirstCmdKeyFile

+ && mountedVolCount > 0

+ && !CheckPasswordCharEncoding (NULL, &VolumePassword))

+ Warning ("UNSUPPORTED_CHARS_IN_PWD_RECOM");

+

+ if (status && CloseSecurityTokenSessionsAfterMount)

+ SecurityToken::CloseAllSessions();

+

+ret:

+ MultipleMountOperationInProgress = FALSE;

+

+ burn (&VolumePassword, sizeof (VolumePassword));

+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

+

+ mountOptions.UseBackupHeader = defaultMountOptions.UseBackupHeader;

+

+ RestoreDefaultKeyFilesParam ();

+

+ if (UsePreferences)

+ bCacheInDriver = bCacheInDriverDefault;

+

+ EnableDisableButtons (hwndDlg);

+

+ NormalCursor();

+

+ return status;

+}

+

+static void ChangePassword (HWND hwndDlg)

+{

+ int result;

+

+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, sizeof (szFileName));

+ if (IsMountedVolume (szFileName))

+ {

+ Warning (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF ? "MOUNTED_NO_PKCS5_PRF_CHANGE" : "MOUNTED_NOPWCHANGE");

+ return;

+ }

+

+ if (!VolumePathExists (szFileName))

+ {

+ handleWin32Error (hwndDlg);

+ return;

+ }

+

+ bSysEncPwdChangeDlgMode = FALSE;

+

+ result = DialogBoxW (hInst, MAKEINTRESOURCEW (IDD_PASSWORDCHANGE_DLG), hwndDlg,

+ (DLGPROC) PasswordChangeDlgProc);

+

+ if (result == IDOK)

+ {

+ switch (pwdChangeDlgMode)

+ {

+ case PCDM_CHANGE_PKCS5_PRF:

+ Info ("PKCS5_PRF_CHANGED");

+ break;

+

+ case PCDM_ADD_REMOVE_VOL_KEYFILES:

+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:

+ Info ("KEYFILE_CHANGED");

+ break;

+

+ case PCDM_CHANGE_PASSWORD:

+ default:

+ Info ("PASSWORD_CHANGED");

+ }

+ }

+}

+

+// Change password of the system partition/drive

+static void ChangeSysEncPassword (HWND hwndDlg, BOOL bOnlyChangeKDF)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ if (!BootEncStatus.DriveEncrypted

+ && !BootEncStatus.DriveMounted

+ && !BootEncStatus.VolumeHeaderPresent

+ && !SysEncryptionOrDecryptionRequired ())

+ {

+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");

+ return;

+ }

+

+ if (SysEncryptionOrDecryptionRequired ()

+ || BootEncStatus.SetupInProgress)

+ {

+ Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED");

+ return;

+ }

+

+ if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption

+ {

+ sprintf (OrigKeyboardLayout, "%08X", (DWORD) GetKeyboardLayout (NULL) & 0xFFFF);

+

+ bSysEncPwdChangeDlgMode = TRUE;

+

+ if (bOnlyChangeKDF)

+ pwdChangeDlgMode = PCDM_CHANGE_PKCS5_PRF;

+ else

+ pwdChangeDlgMode = PCDM_CHANGE_PASSWORD;

+

+

+ INT_PTR result = DialogBoxW (hInst, MAKEINTRESOURCEW (IDD_PASSWORDCHANGE_DLG), hwndDlg, (DLGPROC) PasswordChangeDlgProc);

+

+ bSysEncPwdChangeDlgMode = FALSE;

+

+ if (bKeyboardLayoutChanged)

+ {

+ // Restore the original keyboard layout

+ if (LoadKeyboardLayout (OrigKeyboardLayout, KLF_ACTIVATE | KLF_SUBSTITUTE_OK) == NULL)

+ Warning ("CANNOT_RESTORE_KEYBOARD_LAYOUT");

+ else

+ bKeyboardLayoutChanged = FALSE;

+ }

+

+ bKeybLayoutAltKeyWarningShown = FALSE;

+

+ if (result == IDOK)

+ {

+ switch (pwdChangeDlgMode)

+ {

+ case PCDM_CHANGE_PKCS5_PRF:

+ Info ("PKCS5_PRF_CHANGED");

+

+ if (!IsHiddenOSRunning())

+ {

+ if (AskWarnYesNo ("SYS_HKD_ALGO_CHANGED_ASK_RESCUE_DISK") == IDYES)

+ CreateRescueDisk ();

+ }

+

+ break;

+

+ case PCDM_ADD_REMOVE_VOL_KEYFILES:

+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:

+ // NOP - Keyfiles are not supported for system encryption

+ break;

+

+ case PCDM_CHANGE_PASSWORD:

+ default:

+ Info ("PASSWORD_CHANGED");

+

+ if (!IsHiddenOSRunning())

+ {

+ if (AskWarnYesNo ("SYS_PASSWORD_CHANGED_ASK_RESCUE_DISK") == IDYES)

+ CreateRescueDisk ();

+ }

+ }

+ }

+

+ CloseSysEncMutex ();

+ }

+ else

+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");

+}

+

+// Initiates or resumes encryption of the system partition/drive

+static void EncryptSystemDevice (void)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ if (!BootEncStatus.DriveEncrypted

+ && !BootEncStatus.DriveMounted

+ && !SysEncryptionOrDecryptionRequired ())

+ {

+ // System partition/drive is not encrypted (nothing to resume). Initiate the process.

+

+ if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

+ {

+ LaunchVolCreationWizard (MainDlg, "/sysenc");

+ }

+ else

+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");

+

+ return;

+ }

+ else if (SysEncryptionOrDecryptionRequired ())

+ {

+ // System partition/drive encryption already initiated but is incomplete -- attempt to resume the process.

+ // Note that this also covers the pretest phase and paused decryption (reverses decrypting and starts encrypting)

+

+ if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

+ {

+ LaunchVolCreationWizard (MainDlg, "/sysenc");

+ }

+ else

+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");

+ }

+ else if (SysDriveOrPartitionFullyEncrypted (FALSE))

+ {

+ // System partition/drive appears to be fully encrypted

+ Info ("SYS_PARTITION_OR_DRIVE_APPEARS_FULLY_ENCRYPTED");

+ return;

+ }

+}

+

+// Initiates decryption of the system partition/drive

+static void DecryptSystemDevice (void)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ if (!BootEncStatus.DriveEncrypted

+ && !BootEncStatus.DriveMounted

+ && !BootEncStatus.DeviceFilterActive

+ && !BootEncStatus.VolumeHeaderPresent

+ && !SysEncryptionOrDecryptionRequired ())

+ {

+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");

+ return;

+ }

+

+ if (IsHiddenOSRunning())

+ {

+ Warning ("CANNOT_DECRYPT_HIDDEN_OS");

+ return;

+ }

+

+ if (AskNoYes ("CONFIRM_DECRYPT_SYS_DEVICE") == IDNO)

+ return;

+

+ if (AskWarnNoYes ("CONFIRM_DECRYPT_SYS_DEVICE_CAUTION") == IDNO)

+ return;

+

+ if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption

+ {

+ try

+ {

+ // User-mode app may have crashed and its mutex may have gotten lost, so we need to check the driver status too

+ if (BootEncStatus.SetupInProgress)

+ {

+ int attempts = 20;

+

+ BootEncObj->AbortSetup ();

+ while (BootEncStatus.SetupInProgress && attempts > 0)

+ {

+ Sleep (100);

+ BootEncStatus = BootEncObj->GetStatus();

+ attempts--;

+ WaitCursor();

+ }

+ }

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+ NormalCursor ();

+

+ if (BootEncStatus.SetupInProgress)

+ {

+ CloseSysEncMutex ();

+ Error ("SYS_ENCRYPTION_OR_DECRYPTION_IN_PROGRESS");

+ return;

+ }

+

+ CloseSysEncMutex ();

+ LaunchVolCreationWizard (MainDlg, "/dsysenc");

+ }

+ else

+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");

+}

+

+// Initiates the process of creation of a hidden operating system

+static void CreateHiddenOS (void)

+{

+

+ // Display brief information as to what a hidden operating system is and what it's good for. This needs to be

+ // done, because if the system partition/drive is currently encrypted, the wizard will not display any

+ // such information, but will exit (displaying only an error meessage).

+ Info("HIDDEN_OS_PREINFO");

+

+ LaunchVolCreationWizard (MainDlg, "/isysenc");

+}

+

+// Blindly attempts (without any checks) to instruct the wizard to resume whatever system encryption process

+// had been interrupted or not started but scheduled or exptected to start.

+static void ResumeInterruptedSysEncProcess (void)

+{

+ if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

+ {

+ LaunchVolCreationWizard (MainDlg, "/csysenc");

+ }

+ else

+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");

+}

+

+void CreateRescueDisk (void)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ if (IsHiddenOSRunning())

+ {

+ Warning ("CANNOT_CREATE_RESCUE_DISK_ON_HIDDEN_OS");

+ return;

+ }

+

+ if (!BootEncStatus.DriveEncrypted

+ && !BootEncStatus.DriveMounted

+ && !BootEncStatus.VolumeHeaderPresent

+ && !SysEncryptionOrDecryptionRequired ())

+ {

+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");

+ return;

+ }

+

+ if (SysEncryptionOrDecryptionRequired ()

+ || BootEncStatus.SetupInProgress)

+ {

+ Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED");

+ return;

+ }

+

+ if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption

+ {

+ try

+ {

+ wchar_t szTmp [8096];

+ char szRescueDiskISO [TC_MAX_PATH+1];

+

+ if (AskOkCancel ("RESCUE_DISK_NON_WIZARD_CREATION_SELECT_PATH") != IDOK)

+ {

+ CloseSysEncMutex ();

+ return;

+ }

+

+ char initialDir[MAX_PATH];

+ SHGetFolderPath (NULL, CSIDL_MYDOCUMENTS, NULL, 0, initialDir);

+

+ if (!BrowseFilesInDir (MainDlg, "OPEN_TITLE", initialDir, szRescueDiskISO, FALSE, TRUE, NULL, L"TrueCrypt Rescue Disk.iso", L"iso"))

+ {

+ CloseSysEncMutex ();

+ return;

+ }

+

+ WaitCursor();

+ BootEncObj->CreateRescueIsoImage (false, szRescueDiskISO);

+

+ _snwprintf (szTmp, sizeof szTmp / 2,

+ GetString (IsWindowsIsoBurnerAvailable() ? "RESCUE_DISK_NON_WIZARD_CREATION_WIN_ISOBURN" : "RESCUE_DISK_NON_WIZARD_CREATION_BURN"),

+ szRescueDiskISO);

+

+ if (IsWindowsIsoBurnerAvailable())

+ {

+ if (AskYesNoString (szTmp) == IDYES)

+ LaunchWindowsIsoBurner (MainDlg, szRescueDiskISO);

+ }

+ else

+ InfoDirect (szTmp);

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ Error ("ERROR_CREATING_RESCUE_DISK");

+ }

+ CloseSysEncMutex ();

+

+ NormalCursor ();

+ }

+ else

+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");

+}

+

+static void VerifyRescueDisk (void)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ if (!BootEncStatus.DriveEncrypted

+ && !BootEncStatus.DriveMounted

+ && !BootEncStatus.VolumeHeaderPresent

+ && !SysEncryptionOrDecryptionRequired ())

+ {

+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");

+ return;

+ }

+

+ if (SysEncryptionOrDecryptionRequired ()

+ || BootEncStatus.SetupInProgress)

+ {

+ Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED");

+ return;

+ }

+

+ if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption

+ {

+ try

+ {

+ if (AskOkCancel ("RESCUE_DISK_NON_WIZARD_CHECK_INSERT") != IDOK)

+ {

+ CloseSysEncMutex ();

+ return;

+ }

+

+ // Create a temporary up-to-date rescue disk image in RAM (with it the CD/DVD content will be compared)

+ BootEncObj->CreateRescueIsoImage (false, "");

+

+ WaitCursor();

+ if (!BootEncObj->VerifyRescueDisk ())

+ Error ("RESCUE_DISK_NON_WIZARD_CHECK_FAILED");

+ else

+ Info ("RESCUE_DISK_NON_WIZARD_CHECK_PASSED");

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ Error ("RESCUE_DISK_NON_WIZARD_CHECK_FAILED");

+ }

+ CloseSysEncMutex ();

+

+ NormalCursor ();

+ }

+ else

+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");

+}

+

+static void ShowSystemEncryptionStatus (void)

+{

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ }

+ catch (Exception &e)

+ {

+ e.Show (MainDlg);

+ }

+

+ if (GetAsyncKeyState (VK_SHIFT) < 0 && GetAsyncKeyState (VK_CONTROL) < 0)

+ {

+ // Ctrl+Shift held (for debugging purposes)

+

+ DebugMsgBox ("Debugging information for system encryption:\n\nDeviceFilterActive: %d\nBootLoaderVersion: %x\nSetupInProgress: %d\nSetupMode: %d\nVolumeHeaderPresent: %d\nDriveMounted: %d\nDriveEncrypted: %d\n"

+ "HiddenSystem: %d\nHiddenSystemPartitionStart: %I64d\n"

+ "ConfiguredEncryptedAreaStart: %I64d\nConfiguredEncryptedAreaEnd: %I64d\nEncryptedAreaStart: %I64d\nEncryptedAreaEnd: %I64d\nEncrypted: %I64d%%",

+ BootEncStatus.DeviceFilterActive,

+ BootEncStatus.BootLoaderVersion,

+ BootEncStatus.SetupInProgress,

+ BootEncStatus.SetupMode,

+ BootEncStatus.VolumeHeaderPresent,

+ BootEncStatus.DriveMounted,

+ BootEncStatus.DriveEncrypted,

+ BootEncStatus.HiddenSystem ? 1 : 0,

+ BootEncStatus.HiddenSystemPartitionStart,

+ BootEncStatus.ConfiguredEncryptedAreaStart,

+ BootEncStatus.ConfiguredEncryptedAreaEnd,

+ BootEncStatus.EncryptedAreaStart,

+ BootEncStatus.EncryptedAreaEnd,

+ !BootEncStatus.DriveEncrypted ? 0 : (BootEncStatus.EncryptedAreaEnd + 1 - BootEncStatus.EncryptedAreaStart) * 100I64 / (BootEncStatus.ConfiguredEncryptedAreaEnd + 1 - BootEncStatus.ConfiguredEncryptedAreaStart));

+ }

+

+ if (!BootEncStatus.DriveEncrypted && !BootEncStatus.DriveMounted)

+ {

+ Info ("SYS_DRIVE_NOT_ENCRYPTED");

+ return;

+ }

+

+ DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), MainDlg,

+ (DLGPROC) VolumePropertiesDlgProc, (LPARAM) TRUE);

+

+}

+

+static void ResumeInterruptedNonSysInplaceEncProcess (void)

+{

+ // IMPORTANT: This function must not check any config files! Otherwise, if a config file was lost or corrupt,

+ // the user would not be able resume encryption and the data on the volume would be inaccessible.

+

+ LaunchVolCreationWizard (MainDlg, "/zinplace");

+}

+

+static BOOL SelectContainer (HWND hwndDlg)

+{

+ if (BrowseFiles (hwndDlg, "OPEN_VOL_TITLE", szFileName, bHistory, FALSE, NULL) == FALSE)

+ return FALSE;

+

+ AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, bHistory);

+ EnableDisableButtons (hwndDlg);

+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));

+ return TRUE;

+}

+

+static BOOL SelectPartition (HWND hwndDlg)

+{

+ int nResult = DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_RAWDEVICES_DLG), hwndDlg,

+ (DLGPROC) RawDevicesDlgProc, (LPARAM) & szFileName[0]);

+ if (nResult == IDOK)

+ {

+ AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, bHistory);

+ EnableDisableButtons (hwndDlg);

+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));

+ return TRUE;

+ }

+

+ return FALSE;

+}

+

+static void WipeCache (HWND hwndDlg, BOOL silent)

+{

+ DWORD dwResult;

+ BOOL bResult;

+

+ bResult = DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);

+ if (hwndDlg == NULL)

+ return;

+

+ if (bResult == FALSE)

+ handleWin32Error (hwndDlg);

+ else

+ {

+ EnableDisableButtons (hwndDlg);

+

+ if (!silent)

+ InfoBalloon ("PASSWORD_CACHE_WIPED_SHORT", "PASSWORD_CACHE_WIPED");

+ }

+}

+

+static void Benchmark (HWND hwndDlg)

+{

+ DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_BENCHMARK_DLG), hwndDlg,

+ (DLGPROC) BenchmarkDlgProc, (LPARAM) NULL);

+}

+

+

+static BOOL CheckMountList ()

+{

+ MOUNT_LIST_STRUCT current;

+ static BootEncryptionStatus newBootEncStatus;

+ static BOOL lastbUseDifferentTrayIconIfVolMounted = bUseDifferentTrayIconIfVolMounted;

+ static uint32 lastUlMountedDrives = 0;

+

+ GetMountList (&current);

+

+ if ((current.ulMountedDrives != lastUlMountedDrives || bUseDifferentTrayIconIfVolMounted != lastbUseDifferentTrayIconIfVolMounted)

+ && TaskBarIconMutex != NULL)

+ {

+ lastUlMountedDrives = current.ulMountedDrives;

+ lastbUseDifferentTrayIconIfVolMounted = bUseDifferentTrayIconIfVolMounted;

+

+ TaskBarIconChange (MainDlg, current.ulMountedDrives != 0 && bUseDifferentTrayIconIfVolMounted ? IDI_TRUECRYPT_MOUNTED_ICON : IDI_TRUECRYPT_ICON);

+ }

+

+ if (LastKnownLogicalDrives != GetLogicalDrives()

+ || memcmp (&LastKnownMountList, &current, sizeof (current)) != 0)

+ {

+ char selDrive;

+

+ WaitCursor ();

+ LastKnownMountList = current;

+

+ selDrive = (char) HIWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST)));

+ LoadDriveLetters (GetDlgItem (MainDlg, IDC_DRIVELIST), 0);

+ NormalCursor ();

+

+ if (selDrive != -1 && (current.ulMountedDrives & (1 << (selDrive - 'A'))) == 0 && !IsDriveAvailable (selDrive - 'A'))

+ {

+ nSelectedDriveIndex = -1;

+ return FALSE;

+ }

+

+ if (selDrive != -1)

+ SelectItem (GetDlgItem (MainDlg, IDC_DRIVELIST),selDrive);

+ }

+

+ try

+ {

+ newBootEncStatus = BootEncObj->GetStatus();

+

+ if (newBootEncStatus.SetupInProgress != RecentBootEncStatus.SetupInProgress

+ || newBootEncStatus.EncryptedAreaEnd != RecentBootEncStatus.EncryptedAreaEnd

+ || newBootEncStatus.DriveEncrypted != RecentBootEncStatus.DriveEncrypted

+ || newBootEncStatus.DriveMounted != RecentBootEncStatus.DriveMounted

+ || newBootEncStatus.SetupMode != RecentBootEncStatus.SetupMode

+ || newBootEncStatus.EncryptedAreaStart != RecentBootEncStatus.EncryptedAreaStart)

+ {

+ /* System encryption status change */

+

+ char selDrive;

+ int driveLetterToRefresh;

+

+ if (RecentBootEncStatus.DriveMounted == newBootEncStatus.DriveMounted) // If an icon (and whole new line) for a system device isn't to be added/removed

+ {

+ // Partial refresh

+ if (WholeSysDriveEncryption (TRUE))

+ {

+ // System drive (not just partition)

+ driveLetterToRefresh = ENC_SYSDRIVE_PSEUDO_DRIVE_LETTER;

+ }

+ else

+ {

+ // System partition

+ driveLetterToRefresh = GetSystemDriveLetter ();

+ }

+ }

+ else

+ {

+ // Full rebuild of the mount list

+ driveLetterToRefresh = 0;

+ }

+

+ selDrive = (char) HIWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST)));

+ LoadDriveLetters (GetDlgItem (MainDlg, IDC_DRIVELIST), driveLetterToRefresh);

+

+ RecentBootEncStatus = newBootEncStatus;

+

+ if (selDrive != -1 && (current.ulMountedDrives & (1 << (selDrive - 'A'))) == 0 && !IsDriveAvailable (selDrive - 'A'))

+ {

+ nSelectedDriveIndex = -1;

+ }

+

+ if (selDrive != -1)

+ {

+ SelectItem (GetDlgItem (MainDlg, IDC_DRIVELIST),selDrive);

+ }

+ }

+

+ /* Miscellaneous notifications */

+

+ // Hibernation prevention notifications

+ if (newBootEncStatus.HibernationPreventionCount != RecentBootEncStatus.HibernationPreventionCount

+ && !bHibernationPreventionNotified)

+ {

+ bHibernationPreventionNotified = TRUE;

+ RecentBootEncStatus.HibernationPreventionCount = newBootEncStatus.HibernationPreventionCount;

+

+ if (IsHiddenOSRunning() && BootEncObj->GetSystemDriveConfiguration().ExtraBootPartitionPresent)

+ WarningTopMost ("HIDDEN_OS_HIBERNATION_PREVENTED");

+ else

+ WarningTopMost ("SYS_ENC_HIBERNATION_PREVENTED");

+ }

+

+ // Write mode prevention (hidden OS leak protection)

+ if (IsHiddenOSRunning())

+ {

+ if (newBootEncStatus.HiddenSysLeakProtectionCount != RecentBootEncStatus.HiddenSysLeakProtectionCount

+ && !bHiddenSysLeakProtNotifiedDuringSession)

+ {

+ bHiddenSysLeakProtNotifiedDuringSession = TRUE;

+

+ switch (HiddenSysLeakProtectionNotificationStatus)

+ {

+ case TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_COMPACT:

+ {

+ char *tmp[] = {0, "HIDDEN_OS_WRITE_PROTECTION_BRIEF_INFO", "SHOW_MORE_INFORMATION", "DO_NOT_SHOW_THIS_AGAIN", "CONTINUE", 0};

+ switch (AskMultiChoice ((void **) tmp, FALSE))

+ {

+ case 1:

+ InfoDirect ((wstring (GetString ("HIDDEN_OS_WRITE_PROTECTION_BRIEF_INFO"))

+ + L"\n\n"

+ + GetString ("HIDDEN_OS_WRITE_PROTECTION_EXPLANATION")

+ + L"\n\n\n"

+ + GetString ("DECOY_TO_HIDDEN_OS_DATA_TRANSFER_HOWTO")).c_str());

+ break;

+

+ case 2:

+ // No more warnings will be shown

+ if (ConfigBuffer == NULL)

+ {

+ // We need to load the config file because it is not done automatically when

+ // launched from the sys startup sequence (and SaveSettings would start by _loading_

+ // the settings to cache).

+ LoadSettings (MainDlg);

+ }

+ HiddenSysLeakProtectionNotificationStatus = TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_DISABLED;

+ SaveSettings (MainDlg);

+ break;

+

+ default:

+ // NOP

+ break;

+ }

+ }

+ break;

+

+ case TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_DISABLED:

+ // NOP

+ break;

+

+ case TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_NONE:

+ default:

+ {

+ // First time warning -- include technical explanation

+ InfoDirect ((wstring (GetString ("HIDDEN_OS_WRITE_PROTECTION_BRIEF_INFO"))

+ + L"\n\n"

+ + GetString ("HIDDEN_OS_WRITE_PROTECTION_EXPLANATION")

+ + L"\n\n\n"

+ + GetString ("DECOY_TO_HIDDEN_OS_DATA_TRANSFER_HOWTO")).c_str());

+

+ // Further warnings will not include the explanation (and will allow disabling)

+

+ if (ConfigBuffer == NULL)

+ {

+ // We need to load the config file because it is not done automatically when

+ // launched from the sys startup sequence (and SaveSettings would start by _loading_

+ // the settings to cache).

+ LoadSettings (MainDlg);

+ }

+ HiddenSysLeakProtectionNotificationStatus = TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_COMPACT;

+ SaveSettings (MainDlg);

+ }

+ break;

+ }

+ }

+ }

+ }

+ catch (...)

+ {

+ // NOP

+ }

+

+ return TRUE;

+}

+

+

+/* Except in response to the WM_INITDIALOG and WM_ENDSESSION messages, the dialog box procedure

+ should return nonzero if it processes a message, and zero if it does not. */

+BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)

+{

+ static UINT taskBarCreatedMsg;

+ WORD lw = LOWORD (wParam);

+ WORD hw = HIWORD (wParam);

+ DWORD mPos;

+

+ switch (uMsg)

+ {

+ case WM_HOTKEY:

+

+ HandleHotKey (hwndDlg, wParam);

+ return 1;

+

+ case WM_INITDIALOG:

+ {

+ int exitCode = 0;

+ int modeOfOperation;

+

+ MainDlg = hwndDlg;

+

+ if (IsTrueCryptInstallerRunning())

+ AbortProcess ("TC_INSTALLER_IS_RUNNING");

+

+ // Set critical default options in case UsePreferences is false

+ bPreserveTimestamp = defaultMountOptions.PreserveTimestamp = TRUE;

+

+ ResetWrongPwdRetryCount ();

+

+ ExtractCommandLine (hwndDlg, (char *) lParam);

+

+ try

+ {

+ BootEncStatus = BootEncObj->GetStatus();

+ RecentBootEncStatus = BootEncStatus;

+ }

+ catch (...)

+ {

+ // NOP

+ }

+

+ if (UsePreferences)

+ {

+ // General preferences

+ LoadSettings (hwndDlg);

+

+ // Keyfiles

+ LoadDefaultKeyFilesParam ();

+ RestoreDefaultKeyFilesParam ();

+ }

+

+ if (ComServerMode)

+ {

+ InitDialog (hwndDlg);

+

+ if (!ComServerMain ())

+ {

+ handleWin32Error (hwndDlg);

+ exit (1);

+ }

+ exit (0);

+ }

+

+ if (CmdMountOptionsValid)

+ mountOptions = CmdMountOptions;

+

+ InitMainDialog (hwndDlg);

+

+ try

+ {

+ if (IsHiddenOSRunning())

+ {

+ if (BootEncObj->GetInstalledBootLoaderVersion() > VERSION_NUM)

+ Warning ("UPDATE_TC_IN_HIDDEN_OS_TOO");

+ }

+ else if (SysDriveOrPartitionFullyEncrypted (TRUE)

+ && BootEncObj->GetInstalledBootLoaderVersion() != VERSION_NUM)

+ {

+ Warning ("BOOT_LOADER_VERSION_DIFFERENT_FROM_DRIVER_VERSION");

+ }

+ }

+ catch (...) { }

+

+ // Automount

+ if (bAuto || (Quit && szFileName[0] != 0))

+ {

+ // No drive letter specified on command line

+ if (commandLineDrive == 0)

+ szDriveLetter[0] = (char) GetFirstAvailableDrive () + 'A';

+

+ if (bAutoMountDevices)

+ {

+ defaultMountOptions = mountOptions;

+ if (FirstCmdKeyFile)

+ {

+ KeyFilesEnable = defaultKeyFilesParam.EnableKeyFiles = TRUE;

+ FirstKeyFile = KeyFileCloneAll (FirstCmdKeyFile);

+ defaultKeyFilesParam.FirstKeyFile = KeyFileCloneAll (FirstCmdKeyFile);

+ }

+

+ if (!MountAllDevices (hwndDlg, !Silent && !CmdVolumePasswordValid && IsPasswordCacheEmpty()))

+ exitCode = 1;

+ }

+

+ if (bAutoMountFavorites)

+ {

+ defaultMountOptions = mountOptions;

+ if (FirstCmdKeyFile)

+ {

+ KeyFilesEnable = defaultKeyFilesParam.EnableKeyFiles = TRUE;

+ FirstKeyFile = KeyFileCloneAll (FirstCmdKeyFile);

+ defaultKeyFilesParam.FirstKeyFile = KeyFileCloneAll (FirstCmdKeyFile);

+ }

+

+ if (!MountFavoriteVolumes (FALSE, LogOn))

+ exitCode = 1;

+ }

+

+ if (szFileName[0] != 0 && !IsMountedVolume (szFileName))

+ {

+ BOOL mounted;

+

+ // Cached password

+ mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, NULL, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE);

+

+ // Command line password or keyfiles

+ if (!mounted && (CmdVolumePassword.Length != 0 || FirstCmdKeyFile))

+ {

+ BOOL reportBadPasswd = CmdVolumePassword.Length > 0;

+

+ if (FirstCmdKeyFile)

+ KeyFilesApply (&CmdVolumePassword, FirstCmdKeyFile);

+

+ mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A',

+ szFileName, &CmdVolumePassword, bCacheInDriver, bForceMount,

+ &mountOptions, Silent, reportBadPasswd);

+

+ burn (&CmdVolumePassword, sizeof (CmdVolumePassword));

+ }

+

+ if (FirstCmdKeyFile)

+ {

+ FirstKeyFile = FirstCmdKeyFile;

+ KeyFilesEnable = TRUE;

+ }

+

+ // Ask user for password

+ while (!mounted && !Silent)

+ {

+ VolumePassword.Length = 0;

+

+ strcpy (PasswordDlgVolume, szFileName);

+ if (!AskVolumePassword (hwndDlg, &VolumePassword, NULL, TRUE))

+ break;

+

+ WaitCursor ();

+

+ if (KeyFilesEnable && FirstKeyFile)

+ KeyFilesApply (&VolumePassword, FirstKeyFile);

+

+ mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, &VolumePassword, bCacheInDriver, bForceMount, &mountOptions, FALSE, TRUE);

+

+ burn (&VolumePassword, sizeof (VolumePassword));

+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

+

+ NormalCursor ();

+ }

+

+ if (UsePreferences)

+ {

+ RestoreDefaultKeyFilesParam ();

+ bCacheInDriver = bCacheInDriverDefault;

+ }

+

+ if (mounted > 0)

+ {

+ if (bBeep)

+ MessageBeep (0xFFFFFFFF);

+

+ if (bExplore)

+ OpenVolumeExplorerWindow (szDriveLetter[0] - 'A');

+

+ RefreshMainDlg(hwndDlg);

+

+ if(!Silent)

+ {

+ // Check for deprecated CBC mode

+ modeOfOperation = GetModeOfOperationByDriveNo (szDriveLetter[0] - 'A');

+ if (modeOfOperation == CBC || modeOfOperation == OUTER_CBC)

+ Warning("WARN_CBC_MODE");

+

+ // Check for deprecated 64-bit-block ciphers

+ if (GetCipherBlockSizeByDriveNo (szDriveLetter[0] - 'A') == 64)

+ Warning("WARN_64_BIT_BLOCK_CIPHER");

+

+ // Check for problematic file extensions (exe, dll, sys)

+ if (CheckFileExtension (szFileName))

+ Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING");

+ }

+ }

+ else

+ exitCode = 1;

+ }

+ else if (bExplore && GetMountedVolumeDriveNo (szFileName) != -1)

+ OpenVolumeExplorerWindow (GetMountedVolumeDriveNo (szFileName));

+ else if (szFileName[0] != 0 && IsMountedVolume (szFileName))

+ Warning ("VOL_ALREADY_MOUNTED");

+

+ if (!Quit)

+ RefreshMainDlg(hwndDlg);

+ }

+

+ // Wipe cache

+ if (bWipe)

+ WipeCache (hwndDlg, Silent);

+

+ // Wipe command line password

+ if (CmdVolumePassword.Length != 0)

+ {

+ burn (&CmdVolumePassword, sizeof (CmdVolumePassword));

+ CmdVolumePassword.Length = 0;

+ }

+

+ // Wipe command line keyfiles

+ if (FirstCmdKeyFile)

+ {

+ if (defaultKeyFilesParam.FirstKeyFile)

+ KeyFileRemoveAll (&defaultKeyFilesParam.FirstKeyFile);

+

+ defaultKeyFilesParam.EnableKeyFiles = FALSE;

+

+ if (!Quit)

+ {

+ LoadSettings (hwndDlg);

+ LoadDefaultKeyFilesParam ();

+ RestoreDefaultKeyFilesParam ();

+ }

+ }

+

+ // Dismount

+ if (cmdUnmountDrive > 0)

+ {

+ MOUNT_LIST_STRUCT mountList;

+ DWORD bytesReturned;

+

+ if (DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, NULL, 0, &mountList, sizeof (mountList), &bytesReturned, NULL)

+ && (mountList.ulMountedDrives & (1 << cmdUnmountDrive)) == 0)

+ {

+ Error ("NO_VOLUME_MOUNTED_TO_DRIVE");

+ exitCode = 1;

+ }

+ else if (!Dismount (hwndDlg, cmdUnmountDrive))

+ exitCode = 1;

+ }

+ else if (cmdUnmountDrive == -1)

+ {

+ if (!DismountAll (hwndDlg, bForceUnmount, !Silent, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY))

+ exitCode = 1;

+ }

+

+ // TaskBar icon

+ if (bEnableBkgTask)

+ TaskBarIconAdd (hwndDlg);

+

+ // Quit

+ if (Quit)

+ {

+ if (TaskBarIconMutex == NULL)

+ exit (exitCode);

+

+ MainWindowHidden = TRUE;

+

+ LoadSettings (hwndDlg);

+ LoadDefaultKeyFilesParam ();

+ RestoreDefaultKeyFilesParam ();

+

+ if (!bEnableBkgTask)

+ {

+ if (TaskBarIconMutex)

+ TaskBarIconRemove (hwndDlg);

+ exit (exitCode);

+ }

+ }

+

+ // No command line arguments or only /volume => bring active instance

+ // to foreground if available

+ if (NoCmdLineArgs == 0 || (CmdLineVolumeSpecified && NoCmdLineArgs <= 2))

+ {

+ HWND h = hwndDlg;

+ EnumWindows (FindTCWindowEnum, (LPARAM) &h);

+

+ if (h != hwndDlg

+ && (!IsAdmin() || (GetWindowLongPtr (h, DWLP_USER) & TC_MAIN_WINDOW_FLAG_ADMIN_PRIVILEGES) != 0))

+ {

+ if (CmdLineVolumeSpecified)

+ {

+ COPYDATASTRUCT cd;

+ memcpy (&cd.dwData, WM_COPY_SET_VOLUME_NAME, 4);

+ cd.lpData = szFileName;

+ cd.cbData = strlen (szFileName) + 1;

+

+ SendMessage (h, WM_COPYDATA, (WPARAM)hwndDlg, (LPARAM)&cd);

+ }

+

+ SendMessage (h, TC_APPMSG_MOUNT_SHOW_WINDOW, 0, 0);

+

+ ShowWindow (h, SW_SHOW);

+ SetForegroundWindow (h);

+

+ if (TaskBarIconMutex == NULL)

+ exit (0);

+ }

+ }

+

+ HookMouseWheel (hwndDlg, IDC_VOLUME);

+

+ // Register hot keys

+ if (!RegisterAllHotkeys (hwndDlg, Hotkeys)

+ && TaskBarIconMutex != NULL) // Warn only if we are the first instance of TrueCrypt

+ Warning("HOTKEY_REGISTRATION_ERROR");

+

+ Silent = FALSE;

+

+ GetMountList (&LastKnownMountList);

+ SetTimer (hwndDlg, TIMER_ID_MAIN, TIMER_INTERVAL_MAIN, NULL);

+

+ taskBarCreatedMsg = RegisterWindowMessage ("TaskbarCreated");

+

+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));

+

+ /* Check system encryption status */

+

+ if (!Quit) // Do not care about system encryption or in-place encryption if we were launched from the system startup sequence (the wizard was added to it too).

+ {

+ if (SysEncryptionOrDecryptionRequired ())

+ {

+ if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

+ {

+ // We shouldn't block the mutex at this point

+

+ if (SystemEncryptionStatus == SYSENC_STATUS_PRETEST

+ || AskWarnYesNo ("SYSTEM_ENCRYPTION_RESUME_PROMPT") == IDYES)

+ {

+ // The wizard was not launched during the system startup seq, or the user may have forgotten

+ // to resume the encryption/decryption process.

+

+

+ LaunchVolCreationWizard (hwndDlg, "/csysenc");

+ }

+ }

+ }

+

+ if (bInPlaceEncNonSysPending && !NonSysInplaceEncInProgressElsewhere())

+ {

+ if (AskNonSysInPlaceEncryptionResume() == IDYES)

+ ResumeInterruptedNonSysInplaceEncProcess ();

+ }

+ }

+

+ if (!DisableSystemCrashDetection

+ && IsOSAtLeast (WIN_7))

+ {

+ // Auto-detect a system crash

+

+ const int detectionPeriodInMonthsSinceReleaseDate = 2;

+ int maxYear = TC_RELEASE_DATE_YEAR;

+ int maxMonth = TC_RELEASE_DATE_MONTH + detectionPeriodInMonthsSinceReleaseDate;

+ if (maxMonth > 12)

+ {

+ ++maxYear;

+ maxMonth -= 12;

+ }

+

+ SYSTEMTIME systemTime;

+ GetSystemTime (&systemTime);

+

+ if (systemTime.wYear >= TC_RELEASE_DATE_YEAR

+ && !(systemTime.wYear == TC_RELEASE_DATE_YEAR && systemTime.wMonth < TC_RELEASE_DATE_MONTH)

+ && systemTime.wYear <= maxYear

+ && !(systemTime.wYear == maxYear && systemTime.wMonth > maxMonth))

+ {

+ char winDir[MAX_PATH] = { 0 };

+ GetWindowsDirectory (winDir, sizeof (winDir));

+

+ WIN32_FIND_DATA findData;

+ HANDLE find = FindFirstFile ((string (winDir) + "\\MEMORY.DMP").c_str(), &findData);

+

+ if (find != INVALID_HANDLE_VALUE)

+ {

+ SYSTEMTIME systemTime;

+ FILETIME ft;

+ GetSystemTime (&systemTime);

+ SystemTimeToFileTime (&systemTime, &ft);

+

+ ULARGE_INTEGER sysTime, fileTime;

+ sysTime.HighPart = ft.dwHighDateTime;

+ sysTime.LowPart = ft.dwLowDateTime;

+ fileTime.HighPart = findData.ftLastWriteTime.dwHighDateTime;

+ fileTime.LowPart = findData.ftLastWriteTime.dwLowDateTime;

+

+ // Memory dump must not be older than 10 minutes

+ if (sysTime.QuadPart - fileTime.QuadPart < 10I64 * 1000 * 1000 * 60 * 10)

+ SystemCrashDetected = TRUE;

+

+ FindClose (find);

+ }

+ }

+ }

+

+ DoPostInstallTasks ();

+ ResetCurrentDirectory ();

+ }

+ return 0;

+

+ case WM_MOUSEWHEEL:

+ return HandleDriveListMouseWheelEvent (uMsg, wParam, lParam, FALSE);

+

+ case WM_WINDOWPOSCHANGING:

+ if (MainWindowHidden)

+ {

+ // Prevent window from being shown

+ PWINDOWPOS wp = (PWINDOWPOS)lParam;

+ wp->flags &= ~SWP_SHOWWINDOW;

+ return 0;

+ }

+ return 1;

+

+ case WM_SYSCOMMAND:

+ if (lw == IDC_ABOUT)

+ {

+ DialogBoxW (hInst, MAKEINTRESOURCEW (IDD_ABOUT_DLG), hwndDlg, (DLGPROC) AboutDlgProc);

+ return 1;

+ }

+ return 0;

+

+ case WM_HELP:

+ OpenPageHelp (hwndDlg, 0);

+ return 1;

+

+ case WM_ENDSESSION:

+ if (TaskBarIconMutex != NULL)

+ {

+ if (bDismountOnLogOff)

+ {

+ // Auto-dismount when user logs off

+ DWORD dwResult;

+

+ if (bWipeCacheOnAutoDismount)

+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);

+

+ DismountAll (hwndDlg, bForceAutoDismount, FALSE, 1, 0);

+ }

+

+ TaskBarIconRemove (hwndDlg);

+ }

+ EndMainDlg (hwndDlg);

+ localcleanup ();

+ return 0;

+

+ case WM_POWERBROADCAST:

+ if (wParam == PBT_APMSUSPEND

+ && TaskBarIconMutex != NULL && bDismountOnPowerSaving)

+ {

+ // Auto-dismount when entering power-saving mode

+ DWORD dwResult;

+

+ if (bWipeCacheOnAutoDismount)

+ {

+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);

+ SecurityToken::CloseAllSessions();

+ }

+

+ DismountAll (hwndDlg, bForceAutoDismount, TRUE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);

+ }

+ return 0;

+

+ case WM_TIMER:

+ {

+ // Check mount list and update GUI if needed

+ CheckMountList ();

+

+ // Cache status

+ if (IsPasswordCacheEmpty() == IsWindowEnabled (GetDlgItem (hwndDlg, IDC_WIPE_CACHE)))

+ EnableWindow (GetDlgItem (hwndDlg, IDC_WIPE_CACHE), !IsPasswordCacheEmpty());

+

+ // Check driver warning flags

+ DWORD bytesOut;

+ GetWarningFlagsRequest warnings;

+ if (DeviceIoControl (hDriver, TC_IOCTL_GET_WARNING_FLAGS, NULL, 0, &warnings, sizeof (warnings), &bytesOut, NULL))

+ {

+ if (warnings.SystemFavoriteVolumeDirty)

+ WarningTopMost ("SYS_FAVORITE_VOLUME_DIRTY");

+

+ if (warnings.PagingFileCreationPrevented)

+ WarningTopMost ("PAGING_FILE_CREATION_PREVENTED");

+ }

+

+ if (TaskBarIconMutex != NULL)

+ {

+ // Handle system crash

+ static BOOL systemCrashHandlerLocked = FALSE;

+ if (SystemCrashDetected && !systemCrashHandlerLocked)

+ {

+ systemCrashHandlerLocked = TRUE;

+

+ SetForegroundWindow (hwndDlg);

+ MainWindowHidden = FALSE;

+ ShowWindow (hwndDlg, SW_SHOW);

+ ShowWindow (hwndDlg, SW_RESTORE);

+

+ if (AskYesNoTopmost ("SYSTEM_CRASHED_ASK_REPORT") == IDYES)

+ {

+ if (!IsAdmin() && IsUacSupported())

+ UacAnalyzeKernelMiniDump (hwndDlg);

+ else

+ AnalyzeKernelMiniDump (hwndDlg);

+ }

+ else if (AskYesNoTopmost ("ASK_KEEP_DETECTING_SYSTEM_CRASH") == IDNO)

+ {

+ DisableSystemCrashDetection = TRUE;

+ SaveSettings (hwndDlg);

+ }

+ }

+

+ // Idle auto-dismount

+ if (MaxVolumeIdleTime > 0)

+ DismountIdleVolumes ();

+

+ // Screen saver auto-dismount

+ if (bDismountOnScreenSaver)

+ {

+ static BOOL previousState = FALSE;

+ BOOL running = FALSE;

+ SystemParametersInfo (SPI_GETSCREENSAVERRUNNING, 0, &running, 0);

+

+ if (running && !previousState)

+ {

+ DWORD dwResult;

+ previousState = TRUE;

+

+ if (bWipeCacheOnAutoDismount)

+ {

+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);

+ SecurityToken::CloseAllSessions();

+ }

+

+ DismountAll (hwndDlg, bForceAutoDismount, FALSE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);

+ }

+ else

+ {

+ previousState = running;

+ }

+ }

+

+ // Auto-mount favorite volumes on arrival

+#if TIMER_INTERVAL_MAIN != 500

+#error TIMER_INTERVAL_MAIN != 500

+#endif

+ static int favoritesAutoMountTimerDivisor = 0;

+ if ((++favoritesAutoMountTimerDivisor & 1) && !FavoritesOnArrivalMountRequired.empty())

+ {

+ static bool reentry = false;

+ if (reentry)

+ break;

+

+ reentry = true;

+

+ foreach (FavoriteVolume favorite, FavoritesOnArrivalMountRequired)

+ {

+ if (!favorite.VolumePathId.empty())

+ {

+ if (IsMountedVolume (favorite.Path.c_str()))

+ continue;

+

+ char volDevPath[TC_MAX_PATH];

+ if (QueryDosDevice (favorite.VolumePathId.substr (4, favorite.VolumePathId.size() - 5).c_str(), volDevPath, TC_MAX_PATH) == 0)

+ continue;

+

+ favorite.DisconnectedDevice = false;

+ }

+ else if (favorite.Path.find ("\\\\?\\Volume{") == 0)

+ {

+ string resolvedPath = VolumeGuidPathToDevicePath (favorite.Path);

+ if (resolvedPath.empty())

+ continue;

+

+ favorite.DisconnectedDevice = false;

+ favorite.VolumePathId = favorite.Path;

+ favorite.Path = resolvedPath;

+ }

+

+ if (IsMountedVolume (favorite.Path.c_str()))

+ continue;

+

+ if (!IsVolumeDeviceHosted (favorite.Path.c_str()))

+ {

+ if (!FileExists (favorite.Path.c_str()))

+ continue;

+ }

+ else if (favorite.VolumePathId.empty())

+ continue;

+

+ bool mountedAndNotDisconnected = false;

+ foreach (FavoriteVolume mountedFavorite, FavoritesMountedOnArrivalStillConnected)

+ {

+ if (favorite.Path == mountedFavorite.Path)

+ {

+ mountedAndNotDisconnected = true;

+ break;

+ }

+ }

+

+ if (!mountedAndNotDisconnected)

+ {

+ FavoriteMountOnArrivalInProgress = TRUE;

+ MountFavoriteVolumes (FALSE, FALSE, FALSE, favorite);

+ FavoriteMountOnArrivalInProgress = FALSE;

+

+ FavoritesMountedOnArrivalStillConnected.push_back (favorite);

+ }

+ }

+

+ bool deleted;

+ for (list <FavoriteVolume>::iterator favorite = FavoritesMountedOnArrivalStillConnected.begin();

+ favorite != FavoritesMountedOnArrivalStillConnected.end();

+ deleted ? favorite : ++favorite)

+ {

+ deleted = false;

+

+ if (IsMountedVolume (favorite->Path.c_str()))

+ continue;

+

+ if (!IsVolumeDeviceHosted (favorite->Path.c_str()))

+ {

+ if (FileExists (favorite->Path.c_str()))

+ continue;

+ }

+

+ char volDevPath[TC_MAX_PATH];

+ if (favorite->VolumePathId.size() > 5

+ && QueryDosDevice (favorite->VolumePathId.substr (4, favorite->VolumePathId.size() - 5).c_str(), volDevPath, TC_MAX_PATH) != 0)

+ {

+ continue;

+ }

+

+ favorite = FavoritesMountedOnArrivalStillConnected.erase (favorite);

+ deleted = true;

+ }

+

+ reentry = false;

+ }

+ }

+

+ // Exit background process in non-install mode or if no volume mounted

+ // and no other instance active

+ if (LastKnownMountList.ulMountedDrives == 0

+ && MainWindowHidden

+#ifndef _DEBUG

+ && (bCloseBkgTaskWhenNoVolumes || IsNonInstallMode ())

+ && !SysEncDeviceActive (TRUE)

+#endif

+ && GetDriverRefCount () < 2)

+ {

+ TaskBarIconRemove (hwndDlg);

+ EndMainDlg (hwndDlg);

+ }

+ }

+ return 1;

+

+ case TC_APPMSG_TASKBAR_ICON:

+ {

+ switch (lParam)

+ {

+ case WM_LBUTTONDOWN:

+ SetForegroundWindow (hwndDlg);

+ MainWindowHidden = FALSE;

+ ShowWindow (hwndDlg, SW_SHOW);

+ ShowWindow (hwndDlg, SW_RESTORE);

+ return 1;

+

+ case WM_RBUTTONUP:

+ {

+ POINT pos;

+ HMENU popup = CreatePopupMenu ();

+ int sel, i, n;

+

+ if (MainWindowHidden)

+ {

+ AppendMenuW (popup, MF_STRING, IDM_SHOW_HIDE, GetString ("SHOW_TC"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ }

+ else if (bEnableBkgTask

+ && (!(LastKnownMountList.ulMountedDrives == 0

+ && (bCloseBkgTaskWhenNoVolumes || IsNonInstallMode ())

+ && !SysEncDeviceActive (TRUE)

+ && GetDriverRefCount () < 2)))

+ {

+ AppendMenuW (popup, MF_STRING, IDM_SHOW_HIDE, GetString ("HIDE_TC"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ }

+ AppendMenuW (popup, MF_STRING, IDM_MOUNTALL, GetString ("IDC_MOUNTALL"));

+ AppendMenuW (popup, MF_STRING, IDM_MOUNT_FAVORITE_VOLUMES, GetString ("IDM_MOUNT_FAVORITE_VOLUMES"));

+ AppendMenuW (popup, MF_STRING, IDM_UNMOUNTALL, GetString ("IDC_UNMOUNTALL"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+

+ for (n = 0; n < 2; n++)

+ {

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

+ {

+ if (LastKnownMountList.ulMountedDrives & (1 << i))

+ {

+ wchar_t s[1024];

+ wchar_t *vol = (wchar_t *) LastKnownMountList.wszVolume[i];

+

+ if (wcsstr (vol, L"\\??\\")) vol += 4;

+

+ wstring label = GetFavoriteVolumeLabel (WideToSingleString (vol));

+

+ wsprintfW (s, L"%s %c: (%s)",

+ GetString (n==0 ? "OPEN" : "DISMOUNT"),

+ i + L'A',

+ label.empty() ? vol : label.c_str());

+ AppendMenuW (popup, MF_STRING, n*26 + TRAYICON_MENU_DRIVE_OFFSET + i, s);

+ }

+ }

+ if (LastKnownMountList.ulMountedDrives != 0)

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ }

+

+ AppendMenuW (popup, MF_STRING, IDM_HELP, GetString ("MENU_HELP"));

+ AppendMenuW (popup, MF_STRING, IDM_HOMEPAGE_SYSTRAY, GetString ("HOMEPAGE"));

+ AppendMenuW (popup, MF_STRING, IDM_PREFERENCES, GetString ("IDM_PREFERENCES"));

+ AppendMenuW (popup, MF_STRING, IDM_ABOUT, GetString ("IDM_ABOUT"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDCANCEL, GetString ("EXIT"));

+

+ GetCursorPos (&pos);

+

+ SetForegroundWindow(hwndDlg);

+

+ sel = TrackPopupMenu (popup,

+ TPM_RETURNCMD | TPM_LEFTALIGN | TPM_BOTTOMALIGN | TPM_RIGHTBUTTON,

+ pos.x,

+ pos.y,

+ 0,

+ hwndDlg,

+ NULL);

+

+ if (sel >= TRAYICON_MENU_DRIVE_OFFSET && sel < TRAYICON_MENU_DRIVE_OFFSET + 26)

+ {

+ OpenVolumeExplorerWindow (sel - TRAYICON_MENU_DRIVE_OFFSET);

+ }

+ else if (sel >= TRAYICON_MENU_DRIVE_OFFSET + 26 && sel < TRAYICON_MENU_DRIVE_OFFSET + 26*2)

+ {

+ if (CheckMountList ())

+ {

+ if (Dismount (hwndDlg, sel - TRAYICON_MENU_DRIVE_OFFSET - 26))

+ {

+ wchar_t txt [2048];

+ wsprintfW (txt, GetString ("VOLUME_MOUNTED_AS_DRIVE_LETTER_X_DISMOUNTED"), sel - TRAYICON_MENU_DRIVE_OFFSET - 26 + L'A');

+

+ InfoBalloonDirect (GetString ("SUCCESSFULLY_DISMOUNTED"), txt);

+ }

+ }

+ }

+ else if (sel == IDM_SHOW_HIDE)

+ {

+ ChangeMainWindowVisibility ();

+ }

+ else if (sel == IDM_HOMEPAGE_SYSTRAY)

+ {

+ Applink ("home", TRUE, "");

+ }

+ else if (sel == IDCANCEL)

+ {

+ if ((LastKnownMountList.ulMountedDrives == 0

+ && !SysEncDeviceActive (TRUE))

+ || AskWarnNoYes ("CONFIRM_EXIT") == IDYES)

+ {

+ // Close all other TC windows

+ EnumWindows (CloseTCWindowsEnum, 0);

+

+ TaskBarIconRemove (hwndDlg);

+ SendMessage (hwndDlg, WM_COMMAND, sel, 0);

+ }

+ }

+ else

+ {

+ SendMessage (hwndDlg, WM_COMMAND, sel, 0);

+ }

+

+ PostMessage(hwndDlg, WM_NULL, 0, 0);

+ DestroyMenu (popup);

+ }

+ return 1;

+ }

+ }

+

+ return 0;

+

+ case TC_APPMSG_CLOSE_BKG_TASK:

+ if (TaskBarIconMutex != NULL)

+ TaskBarIconRemove (hwndDlg);

+

+ return 1;

+

+ case TC_APPMSG_SYSENC_CONFIG_UPDATE:

+ LoadSysEncSettings (hwndDlg);

+

+ // The wizard added TrueCrypt.exe to the system startup sequence or performed other operations that

+ // require us to update our cached settings.

+ LoadSettings (hwndDlg);

+

+ return 1;

+

+ case WM_DEVICECHANGE:

+ if (!IgnoreWmDeviceChange && wParam != DBT_DEVICEARRIVAL)

+ {

+ // Check if any host device has been removed and force dismount of volumes accordingly

+ PDEV_BROADCAST_HDR hdr = (PDEV_BROADCAST_HDR) lParam;

+ int m;

+

+ GetMountList (&LastKnownMountList);

+

+ if (wParam == DBT_DEVICEREMOVECOMPLETE && hdr->dbch_devicetype == DBT_DEVTYP_VOLUME)

+ {

+ // File-hosted volumes

+ PDEV_BROADCAST_VOLUME vol = (PDEV_BROADCAST_VOLUME) lParam;

+ int i;

+

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

+ {

+ if ((vol->dbcv_unitmask & (1 << i)) && !(GetLogicalDrives() & (1 << i)))

+ {

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

+ {

+ if (LastKnownMountList.ulMountedDrives & (1 << m))

+ {

+ wchar_t *vol = (wchar_t *) LastKnownMountList.wszVolume[m];

+

+ if (wcsstr (vol, L"\\??\\") == vol)

+ vol += 4;

+

+ if (vol[1] == L':' && i == (vol[0] - (vol[0] <= L'Z' ? L'A' : L'a')))

+ {

+ UnmountVolume (hwndDlg, m, TRUE);

+ WarningBalloon ("HOST_DEVICE_REMOVAL_DISMOUNT_WARN_TITLE", "HOST_DEVICE_REMOVAL_DISMOUNT_WARN");

+ }

+ }

+ }

+ }

+ }

+ }

+

+ // Device-hosted volumes

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

+ {

+ if (LastKnownMountList.ulMountedDrives & (1 << m))

+ {

+ wchar_t *vol = (wchar_t *) LastKnownMountList.wszVolume[m];

+ char volp[MAX_PATH];

+

+ if (wcsstr (vol, L"\\??\\") == vol)

+ vol += 4;

+

+ _snprintf (volp, sizeof(volp), "%ls", vol);

+

+ if (IsVolumeDeviceHosted (volp))

+ {

+ OPEN_TEST_STRUCT ots;

+

+ if (!OpenDevice (volp, &ots, FALSE))

+ {

+ UnmountVolume (hwndDlg, m, TRUE);

+ WarningBalloon ("HOST_DEVICE_REMOVAL_DISMOUNT_WARN_TITLE", "HOST_DEVICE_REMOVAL_DISMOUNT_WARN");

+ }

+ }

+ }

+ }

+

+ // Favorite volumes

+ UpdateDeviceHostedFavoriteVolumes();

+

+ return 1;

+ }

+ return 0;

+

+ case WM_NOTIFY:

+

+ if(wParam == IDC_DRIVELIST)

+ {

+ if (((LPNMHDR) lParam)->code == NM_CUSTOMDRAW)

+ {

+ int width = ListView_GetColumnWidth (GetDlgItem (hwndDlg, IDC_DRIVELIST), 1);

+ if (width != LastDriveListVolumeColumnWidth)

+ {

+ LastDriveListVolumeColumnWidth = width;

+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), 0);

+ }

+ return 0;

+ }

+

+ /* Single click within drive list */

+ if (((LPNMHDR) lParam)->code == LVN_ITEMCHANGED && (((LPNMLISTVIEW) lParam)->uNewState & LVIS_FOCUSED ))

+ {

+ nSelectedDriveIndex = ((LPNMLISTVIEW) lParam)->iItem;

+ EnableDisableButtons (hwndDlg);

+ return 1;

+ }

+

+ /* Double click within drive list */

+ if (((LPNMHDR) lParam)->code == LVN_ITEMACTIVATE)

+ {

+ int state = GetItemLong (GetDlgItem (hwndDlg, IDC_DRIVELIST), ((LPNMITEMACTIVATE)lParam)->iItem );

+ nSelectedDriveIndex = ((LPNMITEMACTIVATE)lParam)->iItem;

+ if (LOWORD(state) == TC_MLIST_ITEM_NONSYS_VOL || LOWORD(state) == TC_MLIST_ITEM_SYS_PARTITION)

+ {

+ // Open explorer window for mounted volume

+ WaitCursor ();

+ OpenVolumeExplorerWindow (HIWORD(state) - 'A');

+ NormalCursor ();

+ }

+ else if (LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == TC_MLIST_ITEM_FREE)

+ {

+ mountOptions = defaultMountOptions;

+ bPrebootPasswordDlgMode = FALSE;

+

+ if (GetAsyncKeyState (VK_CONTROL) < 0)

+ {

+ if (IDCANCEL == DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), hwndDlg,

+ (DLGPROC) MountOptionsDlgProc, (LPARAM) &mountOptions))

+ return 1;

+

+ if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)

+ KeyFilesApply (&mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile);

+ }

+

+ if (CheckMountList ())

+ Mount (hwndDlg, 0, 0);

+ }

+ return 1;

+ }

+

+ /* Right click and drag&drop operations */

+

+ switch (((NM_LISTVIEW *) lParam)->hdr.code)

+ {

+ case NM_RCLICK:

+ case LVN_BEGINRDRAG:

+ /* If the mouse was moving while the right mouse button is pressed, popup menu would

+ not open, because drag&drop operation would be initiated. Therefore, we're handling

+ RMB drag-and-drop operations as well. */

+ {

+

+ /* Drive list context menu */

+

+ int menuItem;

+ HMENU popup = CreatePopupMenu ();

+

+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));

+

+ switch (LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))))

+ {

+ case TC_MLIST_ITEM_FREE:

+

+ // No mounted volume at this drive letter

+

+ AppendMenuW (popup, MF_STRING, IDM_MOUNT_VOLUME, GetString ("IDM_MOUNT_VOLUME"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDPM_SELECT_FILE_AND_MOUNT, GetString ("SELECT_FILE_AND_MOUNT"));

+ AppendMenuW (popup, MF_STRING, IDPM_SELECT_DEVICE_AND_MOUNT, GetString ("SELECT_DEVICE_AND_MOUNT"));

+ break;

+

+ case TC_MLIST_ITEM_NONSYS_VOL:

+

+ // There's a mounted non-system volume at this drive letter

+

+ AppendMenuW (popup, MF_STRING, IDM_UNMOUNT_VOLUME, GetString ("DISMOUNT"));

+ AppendMenuW (popup, MF_STRING, IDPM_OPEN_VOLUME, GetString ("OPEN"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDPM_CHECK_FILESYS, GetString ("IDPM_CHECK_FILESYS"));

+ AppendMenuW (popup, MF_STRING, IDPM_REPAIR_FILESYS, GetString ("IDPM_REPAIR_FILESYS"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDPM_ADD_TO_FAVORITES, GetString ("IDPM_ADD_TO_FAVORITES"));

+ AppendMenuW (popup, MF_STRING, IDPM_ADD_TO_SYSTEM_FAVORITES, GetString ("IDPM_ADD_TO_SYSTEM_FAVORITES"));

+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);

+ AppendMenuW (popup, MF_STRING, IDM_VOLUME_PROPERTIES, GetString ("IDPM_PROPERTIES"));

+ break;

+

+ case TC_MLIST_ITEM_SYS_PARTITION:

+ case TC_MLIST_ITEM_SYS_DRIVE:

+

+ // System partition/drive

+

+ PopulateSysEncContextMenu (popup, FALSE);

+ break;

+ }

+

+ mPos=GetMessagePos();

+

+ menuItem = TrackPopupMenu (popup,

+ TPM_RETURNCMD | TPM_LEFTBUTTON,

+ GET_X_LPARAM(mPos),

+ GET_Y_LPARAM(mPos),

+ 0,

+ hwndDlg,

+ NULL);

+

+ DestroyMenu (popup);

+

+ switch (menuItem)

+ {

+ case IDPM_SELECT_FILE_AND_MOUNT:

+ if (SelectContainer (hwndDlg))

+ MountSelectedVolume (hwndDlg, FALSE);

+ break;

+

+ case IDPM_SELECT_DEVICE_AND_MOUNT:

+ if (SelectPartition (hwndDlg))

+ MountSelectedVolume (hwndDlg, FALSE);

+ break;

+

+ case IDPM_CHECK_FILESYS:

+ case IDPM_REPAIR_FILESYS:

+ {

+ LPARAM lLetter = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));

+

+ if (LOWORD (lLetter) != 0xffff)

+ CheckFilesystem ((char) HIWORD (lLetter) - 'A', menuItem == IDPM_REPAIR_FILESYS);

+ }

+ break;

+

+ case IDM_UNMOUNT_VOLUME:

+ if (CheckMountList ())

+ Dismount (hwndDlg, 0);

+ break;

+

+ case IDPM_OPEN_VOLUME:

+ {

+ int state = GetItemLong(GetDlgItem (hwndDlg, IDC_DRIVELIST), ((LPNMITEMACTIVATE)lParam)->iItem );

+ nSelectedDriveIndex = ((LPNMITEMACTIVATE)lParam)->iItem;

+

+ WaitCursor ();

+ OpenVolumeExplorerWindow (HIWORD(state) - 'A');

+ NormalCursor ();

+ }

+ break;

+

+ case IDM_VOLUME_PROPERTIES:

+ DialogBoxParamW (hInst,

+ MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), hwndDlg,

+ (DLGPROC) VolumePropertiesDlgProc, (LPARAM) FALSE);

+ break;

+

+ case IDM_MOUNT_VOLUME:

+ if (!VolumeSelected(hwndDlg))

+ {

+ Warning ("NO_VOLUME_SELECTED");

+ }

+ else

+ {

+ mountOptions = defaultMountOptions;

+ bPrebootPasswordDlgMode = FALSE;

+

+ if (CheckMountList ())

+ Mount (hwndDlg, 0, 0);

+ }

+ break;

+

+ case IDPM_ADD_TO_FAVORITES:

+ case IDPM_ADD_TO_SYSTEM_FAVORITES:

+ {

+ LPARAM selectedDrive = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));

+

+ if (LOWORD (selectedDrive) == TC_MLIST_ITEM_NONSYS_VOL)

+ AddMountedVolumeToFavorites (hwndDlg, HIWORD (selectedDrive) - 'A', menuItem == IDPM_ADD_TO_SYSTEM_FAVORITES);

+ }

+ break;

+

+ default:

+ SendMessage (MainDlg, WM_COMMAND, menuItem, NULL);

+ break;

+ }

+ return 1;

+ }

+ }

+ }

+ return 0;

+

+ case WM_ERASEBKGND:

+ return 0;

+

+ case WM_COMMAND:

+

+ if (lw == IDCANCEL || lw == IDC_EXIT)

+ {

+ EndMainDlg (hwndDlg);

+ return 1;

+ }