tcformat.c

一个提供档案及Partition作加解密的程式支援以下的加密演算法AESBlowfishCAST5SerpentTriple DESTwofishAES-BlowfishAES-TwofishAES-

	}
	else
	{
		int x;
		char szTmp[512];
		int driveNo;
		WCHAR deviceName[MAX_PATH];

		strcpy ((char *)deviceName, szFileName);
		ToUNICODE ((char *)deviceName);

		driveNo = GetDiskDeviceDriveLetter (deviceName);

		if (!(bHiddenVol && !bHiddenVolHost))	// Do not ask for permission to overwrite an existing volume if we're creating a hidden volume within it
		{
			char drive[] = { driveNo == -1 ? 0 : '(', driveNo + 'A', ':', ')', ' ', 0 };
			char type[20];

			if (strstr (szFileName, "Partition"))
				strcpy (type, strstr (szFileName, "Partition0") == NULL ? "partition" : "device");
			else
				strcpy (type, "device");

			sprintf (szTmp, getstr (IDS_OVERWRITEPROMPT_DEVICE), type, szFileName, drive);

			x = MessageBox (hwndDlg, szTmp, lpszTitle, YES_NO|MB_ICONWARNING|MB_DEFBUTTON2);
			if (x != IDYES)
				goto cancel;
		}

		// Dismount drive if needed
		if (driveNo != -1)
		{
			CloseHandle (DismountDrive (driveNo));
		}

		// If we are encrypting whole device, dismount all partitions located on it first
		if (strstr (szFileName, "\\Partition0"))
		{
			int i, diskNo;
			if (sscanf (szFileName, "\\Device\\Harddisk%d\\", &diskNo) == 1)
			{	
				for (i = 1; i < 32; i++)
				{
					sprintf ((char *)deviceName, "\\Device\\Harddisk%d\\Partition%d", diskNo, i);
					ToUNICODE ((char *)deviceName);

					driveNo = GetDiskDeviceDriveLetter (deviceName);

					if (driveNo != -1)
					{
						if (quickFormat && i > 1)
						{ 
							// Quickformat prevents overwriting of existing filesystems and
							// an eventual remount could corrupt the volume
							MessageBox (hwndDlg, getstr (IDS_ERR_MOUNTED_FILESYSTEMS), lpszTitle, MB_ICONSTOP);
							goto cancel;
						}

						// Handle to dismounted volumes intentionally left open till program exit
						// to prevent remount during format
						DismountDrive (driveNo); 
					}
				}
			}
		}

		nDosLinkCreated = FakeDosNameForDevice (szDiskFile, szDosDevice, szCFDevice, FALSE);
		if (nDosLinkCreated != 0)
		{
			handleWin32Error (hwndDlg);
			goto cancel;
		}
	}

	ArrowWaitCursor ();

	nStatus = FormatVolume (szCFDevice,
				bDevice,
				szDiskFile,
				nVolumeSize,
				nHiddenVolHostSize,
				szPassword,
				nVolumeEA,
				pkcs5,
				quickFormat,
				fileSystem,
				clusterSize,
				summaryMsg,
				hwndDlg,
				bHiddenVol && !bHiddenVolHost,
				&realClusterSize);

	NormalCursor ();

	if (nStatus == ERR_OUTOFMEMORY)
	{
		AbortProcess (IDS_OUTOFMEMORY);
	}

	dwWin32FormatError = GetLastError ();

	if (bHiddenVolHost && !bThreadCancel)
	{
		/* Auto mount the newly created hidden volume host */
		switch (MountHiddenVolHost (hwndDlg, szDiskFile, &hiddenVolHostDriveNo, szPassword))
		{
		case ERR_NO_FREE_DRIVES:
			MessageBox (hwndDlg, "Error: No free drive letter for the outer volume!\nVolume creation cannot continue.", lpszTitle, ICON_HAND);
			break;
		case ERR_VOL_MOUNT_FAILED:
			MessageBox (hwndDlg, "Error: Cannot mount the outer volume!\nVolume creation cannot continue.", lpszTitle, ICON_HAND);
			break;
		}
	}

	if (nDosLinkCreated == 0)
	{
		/* Only comes here when it's WIN_NT & disk partitions */
		int nStatus = RemoveFakeDosName (szDiskFile, szDosDevice);
		if (nStatus != 0)
			handleWin32Error (hwndDlg);
	}

	SetLastError (dwWin32FormatError);

	if (bThreadCancel == TRUE)
	{
		if (bDevice == FALSE)
			remove (szCFDevice);

		goto cancel;
	}

	if (nStatus != 0)
	{
		char szMsg[512];

		if (!(bHiddenVolHost && hiddenVolHostDriveNo < 0))  // If the error was not that the hidden volume host could not be mounted (this error has already been reported to the user)
		{
			sprintf (szMsg, getstr (IDS_CREATE_FAILED), szDiskFile);
			MessageBox (hwndDlg, szMsg, lpszTitle, ICON_HAND);
		}

		if (bDevice == FALSE)
			remove (szCFDevice);

		goto cancel;
	}
	else
	{
		/* Volume successfully created */

		NormalCursor ();

		if (!bHiddenVolHost)
		{
			/* Create the volstats dialog box */
			DialogBoxParam (hInst, MAKEINTRESOURCE (IDD_VOLSTATS_DLG), hwndDlg,
				(DLGPROC) VolstatsDlgProc, (LPARAM) & summaryMsg[0]);

			if (bHiddenVol)
				bHiddenVolFinished = TRUE;
		}
		else
		{
			/* We've just created an outer volume (to host a hidden volume within) */

			MessageBeep (-1);
			bHiddenVolHost = FALSE; 
			bHiddenVolFinished = FALSE;
			nHiddenVolHostSize = nVolumeSize;

			// Clear the outer volume password
			memset(&szPassword[0], 0, sizeof (szPassword));
			memset(&szVerify[0], 0, sizeof (szVerify));
		}

		SetTimer (hwndDlg, 0xff, RANDOM_SHOW_TIMER, NULL);

		PostMessage (hwndDlg, WM_FORMAT_FINISHED, 0, 0);
		bThreadRunning = FALSE;

		NormalCursor ();
		_endthread ();
	}

cancel:

	SetTimer (hwndDlg, 0xff, RANDOM_SHOW_TIMER, NULL);

	PostMessage (hwndDlg, WM_THREAD_ENDED, 0, 0);
	bThreadRunning = FALSE;
	NormalCursor ();

	if (bHiddenVolHost && hiddenVolHostDriveNo < -1 && !bThreadCancel)	// If hidden volume host could not be mounted
		AbortProcessSilent ();

	_endthread ();
}

void
OpenPageHelp (HWND hwndDlg, int nPage)
{
	int r = (int)ShellExecute (NULL, "open", szHelpFile, NULL, NULL, SW_SHOWNORMAL);
	if (nPage);		/* Remove warning */

	if (r == ERROR_FILE_NOT_FOUND)
		MessageBox (hwndDlg, getstr (IDS_HELP_ERROR), lpszTitle, MB_ICONERROR);

	if (r == SE_ERR_NOASSOC)
		MessageBox (hwndDlg, getstr (IDS_HELP_READER_ERROR), lpszTitle, MB_ICONERROR);
}

void
LoadPage (HWND hwndDlg, int nPageNo)
{
	RECT rW, rD;

	if (hCurPage != NULL)
	{
		DestroyWindow (hCurPage);
	}

	nCurPageNo = nPageNo;

	ShowWindow (GetDlgItem (hwndDlg, IDC_POS_BOX), SW_HIDE);
	EnableWindow (GetDlgItem (hwndDlg, IDC_POS_BOX), TRUE);
	GetWindowRect (GetDlgItem (hwndDlg, IDC_POS_BOX), &rW);

	switch (nPageNo)
	{
	case INTRO_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_INTRO_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;

	case HIDDEN_VOL_WIZARD_MODE_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_HIDDEN_VOL_WIZARD_MODE_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;

	case FILE_PAGE:

		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_FILE_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		
		if (bHistoryCmdLine == TRUE)
			EnableWindow (GetDlgItem(hCurPage, IDC_NO_HISTORY),  FALSE);
		else
			EnableWindow (GetDlgItem(hCurPage, IDC_NO_HISTORY),  TRUE);
		break;

	case HIDDEN_VOL_HOST_PRE_CIPHER_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_INFO_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;
	case HIDDEN_VOL_PRE_CIPHER_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_INFO_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;
	case CIPHER_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_CIPHER_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;
	case SIZE_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_SIZE_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;
	case HIDVOL_HOST_PASSWORD_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_HIDVOL_HOST_PASSWORD_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;
	case PASSWORD_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_PASSWORD_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;
	case FORMAT_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE (IDD_FORMAT_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;
	case FORMAT_FINISHED_PAGE:
		hCurPage = CreateDialog (hInst, MAKEINTRESOURCE ((bHiddenVol && !bHiddenVolHost && !bHiddenVolFinished) ? IDD_HIDVOL_HOST_FILL_PAGE_DLG : IDD_INFO_PAGE_DLG), hwndDlg,
					 (DLGPROC) PageDialogProc);
		break;
	}

	rD.left = 162;
	rD.top = 25;
	rD.right = 0;
	rD.bottom = 0;
	MapDialogRect (hwndDlg, &rD);

	if (hCurPage != NULL)
	{
		MoveWindow (hCurPage, rD.left, rD.top, rW.right - rW.left, rW.bottom - rW.top, TRUE);
		ShowWindow (hCurPage, SW_SHOWNORMAL);
		switch (nPageNo)
		{
		case PASSWORD_PAGE:
			CheckCapsLock (hwndDlg, FALSE);
			break;
		}

	}
}

/* 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 WINAPI
VolstatsDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	WORD lw = LOWORD (wParam);

	switch (msg)
	{
	case WM_INITDIALOG:
		SetDefaultUserFont (hwndDlg);
		SetWindowText (GetDlgItem (hwndDlg, IDC_STATS_BOX), (char *) lParam);
		return 1;

	case WM_COMMAND:
		if (lw == IDOK)
		{
			EndDialog (hwndDlg, 0);
			return 1;
		}
		return 0;
	}

	return 0;
}

int
PrintFreeSpace (HWND hwndTextBox, char *lpszDrive, PLARGE_INTEGER lDiskFree)
{
	UINT nResourceString;
	int nMultiplier;
	char szTmp2[256];

	if (lDiskFree->QuadPart < BYTES_PER_KB)
		nMultiplier = 1;
	else if (lDiskFree->QuadPart < BYTES_PER_MB)
		nMultiplier = BYTES_PER_KB;
	else
		nMultiplier = BYTES_PER_MB;

	if (nMultiplier == 1)
	{
		if (bHiddenVol && !bHiddenVolHost)	// If it's a hidden volume
			nResourceString = IDS_MAX_HIDVOL_SIZE_BYTES;
		else if (bDevice == TRUE)
			nResourceString = IDS_DEVICE_FREE_BYTES;
		else
			nResourceString = IDS_DISK_FREE_BYTES;
	}
	else if (nMultiplier == BYTES_PER_KB)
	{
		if (bHiddenVol && !bHiddenVolHost)	// If it's a hidden volume
			nResourceString = IDS_MAX_HIDVOL_SIZE_KB;
		else if (bDevice == TRUE)
			nResourceString = IDS_DEVICE_FREE_KB;
		else
			nResourceString = IDS_DISK_FREE_KB;
	}
	else 
	{
		if (bHiddenVol && !bHiddenVolHost)	// If it's a hidden volume
			nResourceString = IDS_MAX_HIDVOL_SIZE_MB;
		else if (bDevice == TRUE)
			nResourceString = IDS_DEVICE_FREE_MB;
		else
			nResourceString = IDS_DISK_FREE_MB;
	}
 
	if (bHiddenVol && !bHiddenVolHost)	// If it's a hidden volume
	{
		sprintf (szTmp2, getstr (nResourceString), ((double) lDiskFree->QuadPart) / nMultiplier);
		SetWindowText (GetDlgItem (hwndTextBox, IDC_SIZEBOX), szTmp2);
	}
	else
		sprintf (szTmp2, getstr (nResourceString), lpszDrive, ((double) lDiskFree->QuadPart) / nMultiplier);

	SetWindowText (hwndTextBox, szTmp2);

	if (lDiskFree->QuadPart % (__int64) BYTES_PER_MB != 0)
		nMultiplier = BYTES_PER_KB;

	return nMultiplier;
}

void
DisplaySizingErrorText (HWND hwndTextBox)
{
	char szTmp[256];

	if (nCurrentOS == WIN_NT)
	{
		if (translateWin32Error (szTmp, sizeof (szTmp)) == TRUE)
		{
			char szTmp2[256];
			sprintf (szTmp2, "%s\n%s", getstr (IDS_CANNOT_CALC_SPACE), szTmp);
			SetWindowText (hwndTextBox, szTmp2);
		}
		else
		{
			SetWindowText (hwndTextBox, "");
		}
	}
	else
	{
		SetWindowText (hwndTextBox, getstr (IDS_CANNOT_CALC_SPACE));
	}
}

void
EnableDisableFileNext (HWND hComboBox, HWND hMainButton)
{
	LPARAM nIndex = SendMessage (hComboBox, CB_GETCURSEL, 0, 0);
	if (nIndex == CB_ERR)
	{
		EnableWindow (hMainButton, FALSE);
		SetFocus (hComboBox);
	}
	else
	{
		EnableWindow (hMainButton, TRUE);
		SetFocus (hMainButton);
	}
}


// Note: GetFileVolSize is not to be used for devices (only for file-hosted volumes)
BOOL GetFileVolSize (HWND hwndDlg, unsigned __int64 *size)