static int WriteFile_ToHDD(char *NameF, char *msg) //Запись файла на HDD рекордера
{
DWORD nb;
if(OpenInFilePC(NameF) < 0) return -1; //Открыли входной файл для чтения с компьютера
DWORD wSizeB = sCl_B; //Число байт чтения равно числу байт в кластере
LONGLONG SizeToEnd = Size_inF.QuadPart; //Число байт которые осталось записать
DWORD numCl = DWORD((Size_inF.QuadPart + sCl_B - 1) / sCl_B);//Число кластеров необходимое для размещения файла данного размера
if(numCl > maxZapFAT1 - 1 - writeCl)
return MaloMesta(numCl); //"Запись невозможна, на HDD LG нет свободного места."},
if(numCl > 0)
InitProgressBar(numCl, msg);
DWORD n, nCl = 1; //Номер последнего записанного кластера
for(DWORD i=0; i<numCl; i++) //По числу кластеров
{ for(n=nCl+1; n<maxZapFAT1; n++) //Просмотр FAT для поиска первого свободного кластера
if(*(c_FAT1 + n) == 0) break;
if(n >= maxZapFAT1)
return Error1((Lan+190)->msg); //"Запись невозможна, на HDD LG нет свободного места."},
if(wSizeB > SizeToEnd)
{ wSizeB = DWORD(SizeToEnd); //Размер остатка чтения меньше размера кластера
ZeroMemory(bufIO, sCl_B);
}
if(ReadFile(inFile, bufIO, wSizeB, &nb, NULL) == false || nb != wSizeB)
return ErrorSys1((Lan+87)->msg); //"Ошибка при чтении файла."
#if !defined EMULATOR_HDD //НЕТ Режима эмулятора
if(WriteClast1P(n, bufIO) < 0) return -1; //Запись кластера
#endif
if(nCl > 1)
*(c_FAT1 + nCl) = n; //Ссылка на следубщий кластер в цепочке кластеров
else nCl_1 = n; //Номер кластера начала файла
nCl = n; //Последний записанный кластер
SizeToEnd -= wSizeB; //Число байт которые осталось прочитать
if(ProgressBar(wSizeB) < 0) return -1; //Оператор нажал кнопку Прервать
}
*(c_FAT1 + nCl) = 0x0FFFFFFF; //Признак конца цепочки
CloseFile(&inFile);
writeNewCl += numCl; //Число записанных кластеров
return Change_Dir_For_File(NameF); //Изменение каталога (запись нового файла)
}
void DrawProgressBar(int nPercent) {
int nMax;
if(nShowPhase != 1) {
if(! ::nProcessRank) fprintf(stderr, "\n");
InitProgressBar();
nShowPhase = 1;
} // if nShowPhase
nRotateChar = (nRotateChar + 1) % 4;
// nMax = int(double((nPercent*(nScreenWidth-13)))/100.0);
nMax = nBarStart + 1 + int(double((nPercent*(nScreenWidth-nBarStart-12)))/100.0);
for(int i=nBarStart + 1; i<nMax; i++) {
if(i == nMax - 1 && nPercent != 100)
strImage[i] = '>';
else
strImage[i] = '=';
} // for i
sprintf(strImage + nScreenWidth-12, "] %3i %% %c \r", nPercent, *(strRotateImage+nRotateChar));
if(! ::nProcessRank) fprintf(stderr, strImage);
return;
} // DrawProgressBar
TInt DoZipDownload(RFile &aBootFile)
{
TZipInfo z;
z.iRemain=FileSize;
InitProgressBar(0,(TUint)FileSize,_L("LOAD"));
TInt r=Initialise(z);
CHECK(r);
RThread t;
t.SetHandle(z.iThreadHandle);
while (z.iRemain && z.iThreadStatus==KRequestPending)
{
TRequestStatus dummy;
TRequestStatus* pS=&dummy;
r=ReadBlockToBuffer(z, aBootFile);
if (r != KErrNone)
{
PrintToScreen(_L("FAULT: Unzip Error %d\r\n"),r);
if (z.iFileBufW-z.iFileBufR==z.iFileBufSize)
{
PrintToScreen(_L("Check there is only one image\n\rin the zip file.\r\n"));
}
CHECK(r);
}
UpdateProgressBar(0,(TUint)(FileSize-z.iRemain));
t.RequestComplete(pS,0); // same process
while(z.iHeaderDone==0 && z.iThreadStatus==KRequestPending)
{
DELAY(20000);
}
if (z.iHeaderDone==1 && z.iThreadStatus==KRequestPending)
{
// after reading first block, process the header
ProcessHeader(z);
}
} // while
User::WaitForRequest(z.iThreadStatus);
TInt exitType=t.ExitType();
TInt exitReason=t.ExitReason();
if (z.iRemain || exitType!=EExitKill || exitReason!=KErrNone)
{
TBuf<32> exitCat=t.ExitCategory();
PrintToScreen(_L("Exit code %d,%d,%S\n"),exitType,exitReason,&exitCat);
TEST(0);
}
PrintToScreen(_L("Unzip complete\r\n"));
TUint8* pD=Buffer;
TInt len=1024;
r=ReadInputData(pD,len);
TEST(r==KErrEof);
DELAY(20000);
Cleanup(z);
return KErrNone;
}
void
FileTransfer::FileTransferDownload()
{
rfbFileDownloadDataMsg fdd;
m_clientconn->ReadExact((char *)&fdd, sz_rfbFileDownloadDataMsg);
fdd.realSize = Swap16IfLE(fdd.realSize);
fdd.compressedSize = Swap16IfLE(fdd.compressedSize);
char path[rfbMAX_PATH + rfbMAX_PATH + 3];
if (m_bFirstFileDownloadMsg) {
m_dwDownloadBlockSize = fdd.compressedSize;
sprintf(path, "%s\\%s", m_ClientPath, m_ServerFilename);
strcpy(m_DownloadFilename, path);
m_hFiletoWrite = CreateFile(path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, CREATE_ALWAYS, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
int amount = m_sizeDownloadFile / ((m_dwDownloadBlockSize + 1) * 10);
InitProgressBar(0, 0, amount, 1);
m_bFirstFileDownloadMsg = FALSE;
m_bDownloadStarted = TRUE;
}
if ((fdd.realSize == 0) && (fdd.compressedSize == 0)) {
unsigned int mTime;
m_clientconn->ReadExact((char *) &mTime, sizeof(unsigned int));
if (m_hFiletoWrite == INVALID_HANDLE_VALUE) {
CancelDownload("Could not create file");
MessageBox(m_hwndFileTransfer, "Download failed: could not create local file",
"Download Failed", MB_ICONEXCLAMATION | MB_OK);
SendMessage(m_hwndFTProgress, PBM_SETPOS, 0, 0);
// Send message to start download for next selected file.
PostMessage(m_hwndFileTransfer, WM_COMMAND, IDC_FTCOPY, 0);
return;
}
FILETIME Filetime;
Time70ToFiletime(mTime, &Filetime);
SetFileTime(m_hFiletoWrite, &Filetime, &Filetime, &Filetime);
SendMessage(m_hwndFTProgress, PBM_SETPOS, 0, 0);
SetWindowText(m_hwndFTStatus, "");
CloseHandle(m_hFiletoWrite);
ShowClientItems(m_ClientPath);
m_bFirstFileDownloadMsg = TRUE;
m_bDownloadStarted = FALSE;
// Send message to start download for next selected file.
PostMessage(m_hwndFileTransfer, WM_COMMAND, IDC_FTCOPY, 0);
return;
}
char * pBuff = new char [fdd.compressedSize];
DWORD dwNumberOfBytesWritten;
m_clientconn->ReadExact(pBuff, fdd.compressedSize);
ProcessDlgMessage(m_hwndFileTransfer);
if (!m_bTransferEnable) {
CancelDownload("Download cancelled by user");
delete [] pBuff;
return;
}
if (m_hFiletoWrite == INVALID_HANDLE_VALUE) {
CancelDownload("Could not create file");
MessageBox(m_hwndFileTransfer, "Download failed: could not create local file",
"Download Failed", MB_ICONEXCLAMATION | MB_OK);
delete [] pBuff;
return;
}
WriteFile(m_hFiletoWrite, pBuff, fdd.compressedSize, &dwNumberOfBytesWritten, NULL);
m_dwDownloadRead += dwNumberOfBytesWritten;
if (m_dwDownloadRead >= (10 * m_dwDownloadBlockSize)) {
m_dwDownloadRead = 0;
SendMessage(m_hwndFTProgress, PBM_STEPIT, 0, 0);
}
delete [] pBuff;
}
void
FileTransfer::FileTransferUpload()
{
int numOfFilesToUpload = 0, currentUploadIndex = -1;
DWORD sz_rfbFileSize;
DWORD sz_rfbBlockSize= 8192;
DWORD dwNumberOfBytesRead = 0;
unsigned int mTime = 0;
char path[rfbMAX_PATH + rfbMAX_PATH + 2];
BOOL bResult;
numOfFilesToUpload = ListView_GetSelectedCount(m_hwndFTClientList);
if (numOfFilesToUpload < 0) {
SetWindowText(m_hwndFTStatus, "No file selected, nothing to upload.");
BlockingFileTransferDialog(TRUE);
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), FALSE);
return;
}
for (int i = 0; i < numOfFilesToUpload; i++) {
BlockingFileTransferDialog(FALSE);
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), TRUE);
int index = ListView_GetNextItem(m_hwndFTClientList, currentUploadIndex, LVNI_SELECTED);
if (index < 0) {
SetWindowText(m_hwndFTStatus, "No file is selected, nothing to download.");
return;
}
currentUploadIndex = index;
ListView_GetItemText(m_hwndFTClientList, currentUploadIndex, 0, m_ClientFilename, rfbMAX_PATH);
sprintf(path, "%s\\%s", m_ClientPath, m_ClientFilename);
strcpy(m_UploadFilename, path);
WIN32_FIND_DATA FindFileData;
SetErrorMode(SEM_FAILCRITICALERRORS);
HANDLE hFile = FindFirstFile(path, &FindFileData);
SetErrorMode(0);
if (hFile == INVALID_HANDLE_VALUE) {
SetWindowText(m_hwndFTStatus, "Could not find selected file, can't upload");
// Continue with upload of other files.
continue;
} else if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
SetWindowText(m_hwndFTStatus, "Cannot upload a directory");
// Continue with upload of other files.
continue;
} else {
sz_rfbFileSize = FindFileData.nFileSizeLow;
mTime = FiletimeToTime70(FindFileData.ftLastWriteTime);
strcpy(m_ServerFilename, FindFileData.cFileName);
}
FindClose(hFile);
if ((sz_rfbFileSize != 0) && (sz_rfbFileSize <= sz_rfbBlockSize)) sz_rfbBlockSize = sz_rfbFileSize;
m_hFiletoRead = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (m_hFiletoRead == INVALID_HANDLE_VALUE) {
SetWindowText(m_hwndFTStatus, "Upload failed: could not open selected file");
BlockingFileTransferDialog(TRUE);
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), FALSE);
return;
}
char buffer[rfbMAX_PATH + rfbMAX_PATH + rfbMAX_PATH + rfbMAX_PATH + 20];
sprintf(buffer, "Uploading: %s\\%s -> %s\\%s ...",
m_ClientPath, m_ClientFilename, m_ServerPath, m_ServerFilename);
SetWindowText(m_hwndFTStatus, buffer);
sprintf(path, "%s\\%s", m_ServerPath, m_ClientFilename);
ConvertPath(path);
int pathLen = strlen(path);
char *pAllFURMessage = new char[sz_rfbFileUploadRequestMsg + pathLen];
rfbFileUploadRequestMsg *pFUR = (rfbFileUploadRequestMsg *) pAllFURMessage;
char *pFollowMsg = &pAllFURMessage[sz_rfbFileUploadRequestMsg];
pFUR->type = rfbFileUploadRequest;
pFUR->compressedLevel = 0;
pFUR->fNameSize = Swap16IfLE(pathLen);
pFUR->position = Swap32IfLE(0);
memcpy(pFollowMsg, path, pathLen);
m_clientconn->WriteExact(pAllFURMessage, sz_rfbFileUploadRequestMsg + pathLen);
delete [] pAllFURMessage;
if (sz_rfbFileSize == 0) {
SendFileUploadDataMessage(mTime);
} else {
int amount = sz_rfbFileSize / (sz_rfbBlockSize * 10);
InitProgressBar(0, 0, amount, 1);
DWORD dwPortionRead = 0;
char *pBuff = new char [sz_rfbBlockSize];
m_bUploadStarted = TRUE;
while(m_bUploadStarted) {
ProcessDlgMessage(m_hwndFileTransfer);
if (m_bTransferEnable == FALSE) {
SetWindowText(m_hwndFTStatus, "File transfer canceled");
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), FALSE);
BlockingFileTransferDialog(TRUE);
char reason[] = "File transfer canceled by user";
int reasonLen = strlen(reason);
char *pFUFMessage = new char[sz_rfbFileUploadFailedMsg + reasonLen];
rfbFileUploadFailedMsg *pFUF = (rfbFileUploadFailedMsg *) pFUFMessage;
char *pReason = &pFUFMessage[sz_rfbFileUploadFailedMsg];
pFUF->type = rfbFileUploadFailed;
pFUF->reasonLen = Swap16IfLE(reasonLen);
memcpy(pReason, reason, reasonLen);
m_clientconn->WriteExact(pFUFMessage, sz_rfbFileUploadFailedMsg + reasonLen);
delete [] pFUFMessage;
break;
}
bResult = ReadFile(m_hFiletoRead, pBuff, sz_rfbBlockSize, &dwNumberOfBytesRead, NULL);
if (bResult && dwNumberOfBytesRead == 0) {
/* This is the end of the file. */
SendFileUploadDataMessage(mTime);
break;
}
SendFileUploadDataMessage((unsigned short)dwNumberOfBytesRead, pBuff);
dwPortionRead += dwNumberOfBytesRead;
if (dwPortionRead >= (10 * sz_rfbBlockSize)) {
dwPortionRead = 0;
SendMessage(m_hwndFTProgress, PBM_STEPIT, 0, 0);
}
}
if (m_bTransferEnable == FALSE)
break;
m_bUploadStarted = FALSE;
delete [] pBuff;
}
SendMessage(m_hwndFTProgress, PBM_SETPOS, 0, 0);
SetWindowText(m_hwndFTStatus, "");
CloseHandle(m_hFiletoRead);
}
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), FALSE);
BlockingFileTransferDialog(TRUE);
SendFileListRequestMessage(m_ServerPath, 0);
}
/*
ExpandVolume
Sets the volume size in the volume header (and backup header) to a larger value,
and resizes the filesystem within the volume (only NTFS supported)
Parameters:
hwndDlg : HWND
[in] handle to progress dialog
lpszVolume : char *
[in] Pointer to a string that contains the path to the truecrypt volume
pVolumePassword : Password *
[in] Pointer to the volume password
newHostSize : uint64
[in] new value of the volume host size (can be zero for devices,
which means the volume should use all space of the host device)
initFreeSpace : BOOL
[in] if true, the new volume space will be initalized with random data
Return value:
int with Truecrypt error code (ERR_SUCCESS on success)
Remarks: a lot of code is from TrueCrypt 'Common\Password.c' :: ChangePwd()
*/
static int ExpandVolume (HWND hwndDlg, wchar_t *lpszVolume, Password *pVolumePassword, int VolumePkcs5, int VolumePim, uint64 newHostSize, BOOL initFreeSpace)
{
int nDosLinkCreated = 1, nStatus = ERR_OS_ERROR;
wchar_t szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];
wchar_t szDosDevice[TC_MAX_PATH];
char buffer[TC_VOLUME_HEADER_EFFECTIVE_SIZE];
PCRYPTO_INFO cryptoInfo = NULL, ci = NULL;
void *dev = INVALID_HANDLE_VALUE;
DWORD dwError;
BOOL bDevice;
uint64 hostSize=0, newDataAreaSize, currentVolSize;
DWORD HostSectorSize;
FILETIME ftCreationTime;
FILETIME ftLastWriteTime;
FILETIME ftLastAccessTime;
BOOL bTimeStampValid = FALSE;
LARGE_INTEGER headerOffset;
BOOL backupHeader;
byte *wipeBuffer = NULL;
uint32 workChunkSize = TC_VOLUME_HEADER_GROUP_SIZE;
if (pVolumePassword->Length == 0) return -1;
WaitCursor ();
CreateFullVolumePath (szDiskFile, sizeof(szDiskFile), lpszVolume, &bDevice);
if (bDevice == FALSE)
{
wcscpy (szCFDevice, szDiskFile);
}
else
{
nDosLinkCreated = FakeDosNameForDevice (szDiskFile, szDosDevice, sizeof(szDosDevice), szCFDevice, sizeof(szCFDevice), FALSE);
if (nDosLinkCreated != 0) // note: nStatus == ERR_OS_ERROR
goto error;
}
dev = CreateFile (szCFDevice, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (dev == INVALID_HANDLE_VALUE)
goto error;
if (bDevice)
{
/* This is necessary to determine the hidden volume header offset */
if (dev == INVALID_HANDLE_VALUE)
{
goto error;
}
else
{
PARTITION_INFORMATION diskInfo;
DWORD dwResult;
BOOL bResult;
bResult = GetPartitionInfo (lpszVolume, &diskInfo);
if (bResult)
{
hostSize = diskInfo.PartitionLength.QuadPart;
HostSectorSize = TC_SECTOR_SIZE_FILE_HOSTED_VOLUME; //TO DO: get the real host disk sector size
}
else
{
DISK_GEOMETRY driveInfo;
bResult = DeviceIoControl (dev, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
&driveInfo, sizeof (driveInfo), &dwResult, NULL);
if (!bResult)
goto error;
hostSize = driveInfo.Cylinders.QuadPart * driveInfo.BytesPerSector *
driveInfo.SectorsPerTrack * driveInfo.TracksPerCylinder;
HostSectorSize = driveInfo.BytesPerSector;
}
if (hostSize == 0)
{
nStatus = ERR_VOL_SIZE_WRONG;
goto error;
}
}
}
else
{
LARGE_INTEGER fileSize;
if (!GetFileSizeEx (dev, &fileSize))
{
nStatus = ERR_OS_ERROR;
goto error;
}
hostSize = fileSize.QuadPart;
HostSectorSize = TC_SECTOR_SIZE_FILE_HOSTED_VOLUME; //TO DO: get the real host disk sector size
}
if (Randinit ())
{
if (CryptoAPILastError == ERROR_SUCCESS)
nStatus = ERR_RAND_INIT_FAILED;
else
nStatus = ERR_CAPI_INIT_FAILED;
goto error;
}
if (!bDevice && bPreserveTimestamp)
{
/* Remember the container modification/creation date and time, (used to reset file date and time of
file-hosted volumes after password change (or attempt to), in order to preserve plausible deniability
of hidden volumes (last password change time is stored in the volume header). */
if (GetFileTime ((HANDLE) dev, &ftCreationTime, &ftLastAccessTime, &ftLastWriteTime) == 0)
{
bTimeStampValid = FALSE;
MessageBoxW (hwndDlg, GetString ("GETFILETIME_FAILED_PW"), lpszTitle, MB_OK | MB_ICONEXCLAMATION);
}
else
bTimeStampValid = TRUE;
}
// Seek the volume header
headerOffset.QuadPart = TC_VOLUME_HEADER_OFFSET;
if (!SetFilePointerEx ((HANDLE) dev, headerOffset, NULL, FILE_BEGIN))
{
nStatus = ERR_OS_ERROR;
goto error;
}
/* Read in volume header */
nStatus = _lread ((HFILE) dev, buffer, sizeof (buffer));
if (nStatus != sizeof (buffer))
{
// Windows may report EOF when reading sectors from the last cluster of a device formatted as NTFS
memset (buffer, 0, sizeof (buffer));
}
/* Try to decrypt the header */
nStatus = ReadVolumeHeader (FALSE, buffer, pVolumePassword, VolumePkcs5, VolumePim, FALSE, &cryptoInfo, NULL);
if (nStatus == ERR_CIPHER_INIT_WEAK_KEY)
nStatus = 0; // We can ignore this error here
if (nStatus != 0)
{
cryptoInfo = NULL;
goto error;
}
if (cryptoInfo->HeaderFlags & TC_HEADER_FLAG_ENCRYPTED_SYSTEM)
{
nStatus = ERR_SYS_HIDVOL_HEAD_REENC_MODE_WRONG;
goto error;
}
if (bDevice && newHostSize == 0)
{
// this means we shall take all host space as new volume size
newHostSize = hostSize;
}
if ( newHostSize % cryptoInfo->SectorSize != 0 || newHostSize > TC_MAX_VOLUME_SIZE || (bDevice && newHostSize > hostSize) )
{
// 1. must be multiple of sector size
// 2. truecrypt volume size limit
// 3. for devices volume size can't be larger than host size
cryptoInfo = NULL;
nStatus = ERR_PARAMETER_INCORRECT;
goto error;
}
newDataAreaSize = GetVolumeDataAreaSize (newHostSize, cryptoInfo->LegacyVolume);
if (cryptoInfo->LegacyVolume)
{
if (bDevice)
{
if (initFreeSpace)
{
// unsupported
cryptoInfo = NULL;
nStatus = ERR_PARAMETER_INCORRECT;
goto error;
}
else
{
// note: dummy value (only used for parameter checks)
cryptoInfo->VolumeSize.Value = newDataAreaSize - TC_MINVAL_FS_EXPAND;
}
}
else
{
cryptoInfo->VolumeSize.Value = GetVolumeDataAreaSize (hostSize, TRUE);
}
}
currentVolSize = GetVolumeSizeByDataAreaSize (cryptoInfo->VolumeSize.Value, cryptoInfo->LegacyVolume);
if ( newDataAreaSize < cryptoInfo->VolumeSize.Value + TC_MINVAL_FS_EXPAND )
{
// shrinking a volume or enlarging by less then TC_MINVAL_FS_EXPAND is not allowed
cryptoInfo = NULL;
nStatus = ERR_PARAMETER_INCORRECT;
goto error;
}
InitProgressBar ( newHostSize, currentVolSize, FALSE, FALSE, FALSE, TRUE);
if (bVolTransformThreadCancel)
{
SetLastError(0);
nStatus = ERR_USER_ABORT;
goto error;
}
if (!bDevice) {
LARGE_INTEGER liNewSize;
liNewSize.QuadPart=(LONGLONG)newHostSize;
// Preallocate the file
if (!SetFilePointerEx (dev, liNewSize, NULL, FILE_BEGIN)
|| !SetEndOfFile (dev)
|| SetFilePointer (dev, 0, NULL, FILE_BEGIN) != 0)
{
nStatus = ERR_OS_ERROR;
goto error;
}
}
if (initFreeSpace)
{
uint64 startSector;
int64 num_sectors;
// fill new space with random data
startSector = currentVolSize/HostSectorSize ;
num_sectors = (newHostSize/HostSectorSize) - startSector;
if (bDevice && !StartFormatWriteThread())
{
nStatus = ERR_OS_ERROR;
goto error;
}
DebugAddProgressDlgStatus(hwndDlg, L"Writing random data to new space ...\r\n");
SetFormatSectorSize(HostSectorSize);
nStatus = FormatNoFs (hwndDlg, startSector, num_sectors, dev, cryptoInfo, FALSE);
dwError = GetLastError();
StopFormatWriteThread();
SetLastError (dwError);
}
else
{
UpdateProgressBar(newHostSize);
}
if (nStatus != ERR_SUCCESS)
{
dwError = GetLastError();
DebugAddProgressDlgStatus(hwndDlg, L"Error: failed to write random data ...\r\n");
if ( !bDevice ) {
// restore original size of the container file
LARGE_INTEGER liOldSize;
liOldSize.QuadPart=(LONGLONG)hostSize;
if (!SetFilePointerEx (dev, liOldSize, NULL, FILE_BEGIN) || !SetEndOfFile (dev))
{
DebugAddProgressDlgStatus(hwndDlg, L"Warning: failed to restore original size of the container file\r\n");
}
}
SetLastError (dwError);
goto error;
}
RandSetHashFunction (cryptoInfo->pkcs5);
// Re-encrypt the volume header forn non-legacy volumes: backup header first
backupHeader = TRUE;
headerOffset.QuadPart = TC_VOLUME_HEADER_OFFSET + newHostSize - TC_VOLUME_HEADER_GROUP_SIZE;
/* note: updating the header is not neccessary for legay volumes */
while ( !cryptoInfo->LegacyVolume )
{
if (backupHeader)
DebugAddProgressDlgStatus(hwndDlg, L"Writing re-encrypted backup header ...\r\n");
else
DebugAddProgressDlgStatus(hwndDlg, L"Writing re-encrypted primary header ...\r\n");
// Prepare new volume header
nStatus = CreateVolumeHeaderInMemory (hwndDlg, FALSE,
buffer,
cryptoInfo->ea,
cryptoInfo->mode,
pVolumePassword,
cryptoInfo->pkcs5,
VolumePim,
(char*)(cryptoInfo->master_keydata),
&ci,
newDataAreaSize,
0, // hiddenVolumeSize
cryptoInfo->EncryptedAreaStart.Value,
newDataAreaSize,
cryptoInfo->RequiredProgramVersion,
cryptoInfo->HeaderFlags,
cryptoInfo->SectorSize,
TRUE ); // use slow poll
if (ci != NULL)
crypto_close (ci);
if (nStatus != 0)
goto error;
if (!SetFilePointerEx ((HANDLE) dev, headerOffset, NULL, FILE_BEGIN))
{
nStatus = ERR_OS_ERROR;
goto error;
}
nStatus = _lwrite ((HFILE) dev, buffer, TC_VOLUME_HEADER_EFFECTIVE_SIZE);
if (nStatus != TC_VOLUME_HEADER_EFFECTIVE_SIZE)
{
nStatus = ERR_OS_ERROR;
goto error;
}
if ( ( backupHeader && !initFreeSpace )
|| ( bDevice
&& !cryptoInfo->LegacyVolume
&& !cryptoInfo->hiddenVolume
&& cryptoInfo->HeaderVersion == 4 // BUG in TrueCrypt: doing this only for v4 make no sense
&& (cryptoInfo->HeaderFlags & TC_HEADER_FLAG_NONSYS_INPLACE_ENC) != 0
&& (cryptoInfo->HeaderFlags & ~TC_HEADER_FLAG_NONSYS_INPLACE_ENC) == 0 )
)
{
//DebugAddProgressDlgStatus(hwndDlg, L"WriteRandomDataToReservedHeaderAreas() ...\r\n");
nStatus = WriteRandomDataToReservedHeaderAreas (hwndDlg, dev, cryptoInfo, newDataAreaSize, !backupHeader, backupHeader);
if (nStatus != ERR_SUCCESS)
goto error;
}
FlushFileBuffers (dev);
if (!backupHeader)
break;
backupHeader = FALSE;
headerOffset.QuadPart = TC_VOLUME_HEADER_OFFSET; // offset for main header
}
/* header successfully updated */
nStatus = ERR_SUCCESS;
if (bVolTransformThreadCancel)
{
nStatus = ERR_USER_ABORT;
goto error;
}
/* wipe old backup header */
if ( !cryptoInfo->LegacyVolume )
{
byte wipeRandChars [TC_WIPE_RAND_CHAR_COUNT];
byte wipeRandCharsUpdate [TC_WIPE_RAND_CHAR_COUNT];
byte wipePass;
UINT64_STRUCT unitNo;
LARGE_INTEGER offset;
WipeAlgorithmId wipeAlgorithm = TC_WIPE_35_GUTMANN;
if ( !RandgetBytes (hwndDlg, wipeRandChars, TC_WIPE_RAND_CHAR_COUNT, TRUE)
|| !RandgetBytes (hwndDlg, wipeRandCharsUpdate, TC_WIPE_RAND_CHAR_COUNT, TRUE)
)
{
nStatus = ERR_OS_ERROR;
goto error;
}
DebugAddProgressDlgStatus(hwndDlg, L"Wiping old backup header ...\r\n");
wipeBuffer = (byte *) TCalloc (workChunkSize);
if (!wipeBuffer)
{
nStatus = ERR_OUTOFMEMORY;
goto error;
}
offset.QuadPart = currentVolSize - TC_VOLUME_HEADER_GROUP_SIZE;
unitNo.Value = offset.QuadPart;
for (wipePass = 1; wipePass <= GetWipePassCount (wipeAlgorithm); ++wipePass)
{
if (!WipeBuffer (wipeAlgorithm, wipeRandChars, wipePass, wipeBuffer, workChunkSize))
{
ULONG i;
for (i = 0; i < workChunkSize; ++i)
{
wipeBuffer[i] = wipePass;
}
EncryptDataUnits (wipeBuffer, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, cryptoInfo);
memcpy (wipeRandCharsUpdate, wipeBuffer, sizeof (wipeRandCharsUpdate));
}
if ( !SetFilePointerEx (dev, offset, NULL, FILE_BEGIN)
|| _lwrite ((HFILE)dev, (LPCSTR)wipeBuffer, workChunkSize) == HFILE_ERROR
)
{
// Write error
DebugAddProgressDlgStatus(hwndDlg, L"Warning: Failed to wipe old backup header\r\n");
MessageBoxW (hwndDlg, L"WARNING: Failed to wipe old backup header!\n\nIt may be possible to use the current volume password to decrypt the old backup header even after a future password change.\n", lpszTitle, MB_OK | MB_ICONEXCLAMATION);
if (wipePass == 1)
continue; // retry once
// non-critical error - it's better to continue
nStatus = ERR_SUCCESS;
goto error;
}
FlushFileBuffers(dev);
// we don't check FlushFileBuffers() return code, because it fails for devices
// (same implementation in password.c - a bug or not ???)
}
burn (wipeRandChars, TC_WIPE_RAND_CHAR_COUNT);
burn (wipeRandCharsUpdate, TC_WIPE_RAND_CHAR_COUNT);
}
error:
dwError = GetLastError ();
if (wipeBuffer)
{
burn (wipeBuffer, workChunkSize);
TCfree (wipeBuffer);
wipeBuffer = NULL;
}
burn (buffer, sizeof (buffer));
if (cryptoInfo != NULL)
crypto_close (cryptoInfo);
if (bTimeStampValid)
{
// Restore the container timestamp (to preserve plausible deniability of possible hidden volume).
if (SetFileTime (dev, &ftCreationTime, &ftLastAccessTime, &ftLastWriteTime) == 0)
MessageBoxW (hwndDlg, GetString ("SETFILETIME_FAILED_PW"), lpszTitle, MB_OK | MB_ICONEXCLAMATION);
}
if (dev != INVALID_HANDLE_VALUE)
CloseHandle ((HANDLE) dev);
if (nDosLinkCreated == 0)
RemoveFakeDosName (szDiskFile, szDosDevice);
RandStop (FALSE);
if (bVolTransformThreadCancel)
nStatus = ERR_USER_ABORT;
SetLastError (dwError);
if (nStatus == ERR_SUCCESS)
{
nStatus = ExtendFileSystem (hwndDlg, lpszVolume, pVolumePassword, VolumePkcs5, VolumePim, newDataAreaSize);
}
return nStatus;
}
//11static int Copy_One_File(PAR_FILE *pf, char *msg, char *fName) //Копирование одного файла
static int Copy_One_File(PAR_FILE *pf, char *msg) //Копирование одного файла
{
BYTE buff[sCl_B]; //Память под один кластер
DWORD nb;
#if !defined EMULATOR_HDD_AND_COPY //НЕТ Режима эмулятора с эмуляцией копирования
ZeroMemory(buff, sCl_B); //Очистка буфера чтения
#endif
DWORD wSizeB = sCl_B; //Число записываемых байт равно числу байт в кластере
DWORD nCl = pf->ClSt; //Текущий номер кластера равен первому кластеру файла
LONGLONG SizeToEnd = pf->SizeF; //Число байт которые осталось записать
DWORD numCl = DWORD((pf->SizeF + sCl_B - 1) / sCl_B); //Число кластеров необходимое для размещения файла данного размера
if(numCl > 0)
InitProgressBar(numCl, msg);
for(DWORD i=0; i<numCl; i++) //По числу кластеров
{ if(nCl == 0x0FFFFFFF) //Признак конца цепочки
return Error1((Lan+12)->msg); //return Error1("Неожиданно найден признак конца цепочки FAT.");
if(*(FAT1 + nCl) == 0) //Ненормальная ситуация
return Error1((Lan+11)->msg); //return Error1("Обнаружено несоответствие значения FAT и ссылки на кластер файла.");
if(wSizeB > SizeToEnd)
//11 wSizeB = DWORD(((SizeToEnd + 511) / 512) * 512); //Размер остатка записи меньше размера кластера ?? Почему сектор
wSizeB = DWORD(SizeToEnd); //Размер остатка записи меньше размера кластера
#if !defined EMULATOR_HDD_AND_COPY //НЕТ Режима эмулятора с эмуляцией копирования
DWORD nSector = Start_SecDir1 + (nCl - 1) * sClSec; //Сектор начала текущего кластера
if(ReadClast1_P(nSector, buff) < 0) return -1; //Чтение очeредного кластера
#endif
if(WriteFile(outFile, buff, wSizeB, &nb, NULL) == false || nb != wSizeB)
return ErrorSys1((Lan+83)->msg); //return ErrorSys1("Ошибка при записи выходного файла.");
SizeToEnd -= wSizeB; //Число байт которые осталось записать
nCl = *(FAT1 + nCl); //Номер следующего кластера
if(nCl > maxZapFAT1 && nCl != 0x0FFFFFFF)
return Error1((Lan+13)->msg); //"Номер кластера превышает допустимое значение."
if(SizeToEnd == 0 && nCl != 0x0FFFFFFF)
Error1((Lan+29)->msg); //return Error2("Выходной файл заданного размера записан,", "а признак конца цепочки FAT не найден.");
if(ProgressBar(wSizeB) < 0) return -1; //Оператор нажал кнопку Прервать
}
CloseFile(&outFile); //Закрыли выходной файл
/*11
if((pf->SizeF % sCl_B) != 0) //Размер файла не является кратным размеру кластера
{
int n = 0; //Счетчик для ожидания освобождения файла
if(Open_FileR(fName, &outFile, &n) < 0) //Открытие выходного файла
return -1;
LARGE_INTEGER TPoz;
TPoz.QuadPart = pf->SizeF;
TPoz.u.LowPart = SetFilePointer(outFile, TPoz.u.LowPart, &TPoz.u.HighPart, FILE_BEGIN);
if(TPoz.u.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR)
return ErrorSys1((Lan+83)->msg); //"Ошибка при позиционировании по диску."
if(SetEndOfFile(outFile) == false)
return ErrorSys1((Lan+83)->msg); //return ErrorSys1("Ошибка при записи выходного файла.");
}
*/
FILETIME fTime, flTime;
SYSTEMTIME sysTime;
sysTime.wYear = pf->Year;
sysTime.wMonth = pf->Mon;
// sysTime.wDayOfWeek = 0;
sysTime.wDay = pf->Day;
sysTime.wHour = pf->Hour;
sysTime.wMinute = pf->Min;
sysTime.wSecond = pf->Sec;
sysTime.wMilliseconds = 0;
SystemTimeToFileTime(&sysTime, &flTime); //Преобразовали время
LocalFileTimeToFileTime(&flTime, &fTime);
SetFileTime(outFile, &fTime, &fTime, &fTime); //Дата файла
return 0;
int main(int argc, char **argv)
{
int i, j, k, treeNo, sumLength;
char ch;
TTree **treeSet;
FILE *text_fv;
clock_t totalStart;
double totalSecs, scale, sum;
char *ancestor;
totalStart = clock();
ReadParams(argc, argv);
if (rateHetero == CodonRates && invariableSites) {
fprintf(stderr, "Invariable sites model cannot be used with codon rate heterogeneity.\n");
exit(4);
}
if (writeAncestors && fileFormat == NEXUSFormat) {
fprintf(stderr, "Warning - When writing ancestral sequences, relaxed PHYLIP format is used.\n");
}
if (writeAncestors && maxPartitions > 1) {
fprintf(stderr, "Writing ancestral sequences can only be used for a single partition.\n");
exit(4);
}
if (!userSeed)
randomSeed = CreateSeed();
SetSeed(randomSeed);
if (!quiet)
PrintTitle();
numTrees = OpenTreeFile();
/* if (!treeFile) { */
ReadFileParams();
/*} */
if ((ancestorSeq>0 && !hasAlignment) || ancestorSeq>numSequences) {
fprintf(stderr, "Bad ancestral sequence number: %d (%d sequences loaded)\n", ancestorSeq, numSequences);
exit(4);
}
if (textFile) {
if ( (text_fv=fopen(textFileName, "rt"))==NULL ) {
fprintf(stderr, "Error opening text file for insertion into output: '%s'\n", textFileName);
exit(4);
}
}
ancestor=NULL;
if (hasAlignment) {
AllocateMemory();
ReadFile();
if (numSites<0)
numSites=numAlignmentSites;
if (ancestorSeq>0) {
if (numSites!=numAlignmentSites) {
fprintf(stderr, "Ancestral sequence is of a different length to the simulated sequences (%d)\n", numAlignmentSites);
exit(4);
}
ancestor=sequences[ancestorSeq-1];
}
} else if (numSites<0)
numSites=1000;
SetModel(model);
numTaxa=-1;
scale=1.0;
treeSet = (TTree **)malloc(sizeof(TTree **) * maxPartitions);
if (treeSet==NULL) {
fprintf(stderr, "Out of memory\n");
exit(5);
}
partitionLengths = (int *)malloc(sizeof(int) * maxPartitions);
if (partitionLengths==NULL) {
fprintf(stderr, "Out of memory\n");
exit(5);
}
partitionRates = (double *)malloc(sizeof(double) * maxPartitions);
if (partitionRates==NULL) {
fprintf(stderr, "Out of memory\n");
exit(5);
}
for (i = 0; i < maxPartitions; i++) {
if ((treeSet[i]=NewTree())==NULL) {
fprintf(stderr, "Out of memory\n");
exit(5);
}
}
CreateRates();
treeNo=0;
do {
partitionLengths[0] = -1;
ReadTree(tree_fv, treeSet[0], treeNo+1, 0, NULL, &partitionLengths[0], &partitionRates[0]);
if (treeNo==0) {
numTaxa=treeSet[0]->numTips;
if (!quiet)
fprintf(stderr, "Random number generator seed: %ld\n\n", randomSeed);
if (fileFormat == NEXUSFormat) {
fprintf(stdout, "#NEXUS\n");
fprintf(stdout, "[\nGenerated by %s %s\n\n", PROGRAM_NAME, VERSION_NUMBER);
PrintVerbose(stdout);
fprintf(stdout, "]\n\n");
}
} else if (treeSet[0]->numTips != numTaxa) {
fprintf(stderr, "All trees must have the same number of tips.\n");
exit(4);
}
if (maxPartitions == 1) {
if (partitionLengths[0] != -1) {
fprintf(stderr, "\nWARNING: The treefile contained partion lengths but only one partition\n");
fprintf(stderr, "was specified.\n");
}
partitionLengths[0] = numSites;
}
sumLength = partitionLengths[0];
i = 1;
while (sumLength < numSites && i <= maxPartitions) {
if (!IsTreeAvail(tree_fv)) {
fprintf(stderr, "\nA set of trees number %d had less partition length (%d) than\n", treeNo + 1, sumLength);
fprintf(stderr, "was required to make a sequence of length %d.\n", numSites);
exit(4);
}
ReadTree(tree_fv, treeSet[i], treeNo+1, treeSet[0]->numTips, treeSet[0]->names,
&partitionLengths[i], &partitionRates[i]);
if (treeSet[i]->numTips != numTaxa) {
fprintf(stderr, "All trees must have the same number of tips.\n");
exit(4);
}
sumLength += partitionLengths[i];
i++;
}
if (i > maxPartitions) {
fprintf(stderr, "\nA set of trees number %d had more partitions (%d) than\n", treeNo + 1, i);
fprintf(stderr, "was specified in the user options (%d).\n", maxPartitions);
}
numPartitions = i;
if (sumLength != numSites) {
fprintf(stderr, "The sum of the partition lengths in the treefile does not equal\n");
fprintf(stderr, "the specified number of sites.\n");
exit(4);
}
for (i = 0; i < numPartitions; i++)
CreateSequences(treeSet[i], partitionLengths[i]);
if (numPartitions > 1) {
sum = 0.0;
for (i = 0; i < numPartitions; i++)
sum += partitionRates[i] * partitionLengths[i];
for (i = 0; i < numPartitions; i++)
partitionRates[i] *= numSites / sum;
}
if (treeNo==0 && verbose && !quiet) {
PrintVerbose(stderr);
InitProgressBar(numTrees*numDatasets);
DrawProgressBar();
}
for (i=0; i<numDatasets; i++) {
SetCategories();
k = 0;
for (j = 0; j < numPartitions; j++) {
scale = partitionRates[j];
if (scaleTrees) {
if (!treeSet[j]->rooted) {
fprintf(stderr, "To scale tree length, they must be rooted and ultrametric.\n");
exit(4);
}
scale *= treeScale/treeSet[j]->totalLength;
} else if (scaleBranches)
scale *= branchScale;
EvolveSequences(treeSet[j], k, partitionLengths[j], scale, ancestor);
k += partitionLengths[j];
}
if (writeAncestors)
WriteAncestralSequences(stdout, treeSet[0]);
else
WriteSequences(stdout, (numTrees > 1 ? treeNo+1 : -1), (numDatasets > 1 ? i+1 : -1), treeSet, partitionLengths);
if (writeRates) {
WriteRates(stderr);
}
if (textFile) {
while (!feof(text_fv)) {
ch = fgetc(text_fv);
if (!feof(text_fv))
fputc(ch, stdout);
}
fputc('\n', stdout);
rewind(text_fv);
}
if (verbose && !quiet)
ProgressBar();
}
for (i = 0; i < numPartitions; i++)
DisposeTree(treeSet[i]);
treeNo++;
} while (IsTreeAvail(tree_fv));
/* for (i = 0; i < maxPartitions; i++)
FreeTree(treeSet[i]); */
if (treeFile)
fclose(tree_fv);
if (textFile)
fclose(text_fv);
totalSecs = (double)(clock() - totalStart) / CLOCKS_PER_SEC;
if (!quiet) {
fprintf(stderr, "Time taken: %G seconds\n", totalSecs);
if (verboseMemory)
fprintf(stderr, "Total memory used: %ld\n", totalMem);
}
return 0;
}
