static BOOL CreateFatReferedMap(RDWRHandle handle)
{
unsigned long LabelsInFat;
CLUSTER current, label;
LabelsInFat = GetLabelsInFat(handle);
if (!LabelsInFat) return FAIL;
FatReferedMap = CreateVFSBitField(handle, LabelsInFat);
if (!FatReferedMap) return FAIL;
for (current = 2; current < LabelsInFat; current++)
{
if (!GetNthCluster(handle, current, &label))
return FALSE;
if (FAT_NORMAL(label))
{
if (!SetVFSBitfieldBit(FatReferedMap, label))
return FALSE;
}
}
return TRUE;
}
BOOL FragmentVolume(RDWRHandle handle, unsigned long index, CLUSTER* from, CLUSTER* to)
{
unsigned long labelsinfat;
CLUSTER current;
CLUSTER freeSpace;
char acFName[1000];
char acVFSFName[1000];
labelsinfat = GetLabelsInFat(handle);
if (!labelsinfat)
return FALSE;
current = random_cluster(handle, labelsinfat);
freeSpace = random_freeSpace(handle, labelsinfat);
*from = current;
*to = freeSpace;
// CreateLogFileName(index, current, freeSpace, acFName);
// CreateVFSLogFileName(index, current, freeSpace, acVFSFName);
// if (!OpenLogFile(acFName))
// return FALSE;
// if (!OpenVFSlogFile(acVFSFName))
// return FALSE;
// if (IsClusterUsed(handle, freeSpace) == FALSE)
{
if (!EnsureClustersFree(handle, freeSpace, 1))
return FALSE;
if (!RelocateCluster(handle, current, freeSpace))
return FALSE;
}
// CloseLogFile();
// CloseVFSLogFile();
return TRUE;
}
/*************************************************************************
** RecoverFileChains
**************************************************************************
** Goes through the FAT and converts every cluster chain to a valid file.
**************************************************************************/
static BOOL RecoverFileChains(RDWRHandle handle)
{
unsigned long LabelsInFat, i;
unsigned long filesize;
CLUSTER label;
LabelsInFat = GetLabelsInFat(handle);
if (!LabelsInFat) return FALSE;
for (i = 2; i < LabelsInFat; i++)
{
if (!GetNthCluster(handle, i, &label))
return FALSE;
if (FAT_NORMAL(label) || (label == FAT_LAST_LABEL))
{
switch (IsStartOfChain(handle, i))
{
case TRUE:
if (!RecoverFileChain(handle, i, &filesize))
return FALSE;
if (filesize)
{
if (!AddToRootDir(handle, i, filesize))
return FALSE;
}
break;
case FAIL:
return FALSE;
}
}
}
return TRUE;
}
BOOL ScanFileChain(RDWRHandle handle, CLUSTER firstcluster,
struct DirectoryPosition* pos,
struct DirectoryEntry* entry,
char* filename,
BOOL fixit)
{
char* bitfield;
unsigned long labelsinfat;
BOOL breakoff = FALSE;
CLUSTER current = firstcluster, label, breakingcluster, lengthBreakingCluster=0;
unsigned long length = 0, calculatedsize, bytespercluster;
static char tempbuf[255];
BOOL retVal = TRUE;
/* If it is a root directory that we have to scan see wether it is
a FAT32 volume and if it is get the root cluster */
if (!firstcluster)
{
switch (GetFatLabelSize(handle))
{
case FAT12:
case FAT16:
return TRUE;
case FAT32:
current = GetFAT32RootCluster(handle);
break;
default:
return FAIL;
}
}
else
{
bytespercluster = GetSectorsPerCluster(handle) * BYTESPERSECTOR;
if (!bytespercluster) return FAIL;
calculatedsize = (entry->filesize / bytespercluster) +
((entry->filesize % bytespercluster) > 0);
}
labelsinfat = GetLabelsInFat(handle);
if (!labelsinfat) return FAIL;
bitfield = CreateBitField(labelsinfat);
if (!bitfield)
{
DestroyBitfield(bitfield);
return FAIL;
}
SetBitfieldBit(bitfield, current);
/* Initialise the checks on the directory entries */
if (entry->attribute & FA_DIREC)
{
InitClusterEntryChecking(handle, current, filename);
switch (PreProcessClusterEntryChecking(handle, current, filename, fixit))
{
case FALSE:
retVal = FALSE;
break;
case FAIL:
DestroyBitfield(bitfield);
DestroyClusterEntryChecking(handle, current, filename);
return FAIL;
}
}
while (TRUE)
{
length++;
if (!GetNthCluster(handle, current, &label))
{
DestroyBitfield(bitfield);
if (entry->attribute & FA_DIREC)
DestroyClusterEntryChecking(handle, current, filename);
return FAIL;
}
/* Check the read cluster: */
/* the last cluster */
if (FAT_LAST(label))
{
if (entry->attribute & FA_DIREC) /* Here the current cluster is valid */
{
switch (CheckEntriesInCluster(handle, current, filename, fixit))
{
case FALSE:
retVal = FALSE;
break;
case FAIL:
DestroyBitfield(bitfield);
if (entry->attribute & FA_DIREC)
DestroyClusterEntryChecking(handle, current, filename);
return FAIL;
}
}
break;
}
/* Check wether it is in range */
if (FAT_NORMAL(label) && !IsLabelValid(handle, label))
{
if (firstcluster)
{
ShowFileNameViolation(handle, filename,
"%s contains an invalid cluster");
}
else
{
ShowFileNameViolation(handle, filename,
"The root directory contains an invalid cluster");
}
breakoff = TRUE;
breakingcluster = current;
retVal = FALSE;
}
/* bad cluster */
if (FAT_BAD(label))
{
if (firstcluster)
{
ShowFileNameViolation(handle, filename,
"%s contains a bad cluster");
}
else
{
ShowFileNameViolation(handle, filename,
"The root directory contains a bad cluster");
}
breakingcluster = current;
breakoff = TRUE;
retVal = FALSE;
}
if (FAT_FREE(label))
{
if (firstcluster)
{
ShowFileNameViolation(handle, filename,
"%s contains a free cluster");
}
else
{
ShowFileNameViolation(handle, filename,
"The root directory contains a free cluster");
}
breakoff = TRUE;
breakingcluster = current;
retVal = FALSE;
}
/* Check wether there is a loop */
if (!breakoff && GetBitfieldBit(bitfield, label))
{
if (firstcluster)
{
ShowFileNameViolation(handle, filename,
"%s contains a loop");
}
else
{
ShowFileNameViolation(handle, filename,
"The root directory contains a loop");
}
breakoff = TRUE;
breakingcluster = current;
retVal = FALSE;
}
/*
if ((firstcluster && ((entry->attribute & FA_DIREC) == 0)) &&
(length > calculatedsize) &&
(lengthBreakingCluster == 0))
{
lengthBreakingCluster = current;
}
*/
if (breakoff)
{
if (fixit)
{
if (!WriteFatLabel(handle, breakingcluster, FAT_LAST_LABEL))
{
DestroyBitfield(bitfield);
if (entry->attribute & FA_DIREC)
DestroyClusterEntryChecking(handle, current, filename);
return FAIL;
}
}
break;
}
SetBitfieldBit(bitfield, label);
if (entry->attribute & FA_DIREC) /* Here the current cluster is valid */
{
switch (CheckEntriesInCluster(handle, current, filename, fixit))
{
case FALSE:
retVal = FALSE;
break;
case FAIL:
DestroyBitfield(bitfield);
if (entry->attribute & FA_DIREC)
DestroyClusterEntryChecking(handle, current, filename);
return FAIL;
}
}
current = label;
}
/* Check the length of the file */
if (firstcluster)
{
/*
if (((entry->attribute & FA_DIREC) == 0) && (length > calculatedsize))
{
sprintf(tempbuf,
"%%s has an invalid size, the size should be about %lu, but the entry says it's %lu",
length * bytespercluster, entry->filesize);
ShowFileNameViolation(handle, filename, tempbuf);
if (fixit &&
!WriteFatLabel(handle, lengthBreakingCluster, FAT_LAST_LABEL))
{
DestroyBitfield(bitfield);
if (entry->attribute & FA_DIREC)
DestroyClusterEntryChecking(handle, current, filename);
return FAIL;
}
retVal = FALSE;
}
*/
if (((entry->attribute & FA_DIREC) == 0) && (length != calculatedsize))
{
sprintf(tempbuf,
"%%s has an invalid size, the size should be about %lu, but the entry says it's %lu",
length * bytespercluster, entry->filesize);
ShowFileNameViolation(handle, filename, tempbuf);
if (fixit)
{
/* Notice that we are modifying the filesize of the same entry in chkentrs.c,
the entry shall be written to disk there. */
entry->filesize = length * bytespercluster;
}
retVal = FALSE;
}
}
/* Destroy the checks on the directory entries */
if (entry->attribute & FA_DIREC)
{
switch (PostProcessClusterEntryChecking(handle, current, filename, fixit))
{
case FALSE:
retVal = FALSE;
break;
case FAIL:
retVal = FAIL;
}
DestroyClusterEntryChecking(handle, current, filename);
}
DestroyBitfield(bitfield);
return retVal;
}
static BOOL FilesSummaryGetter(RDWRHandle handle,
struct DirectoryPosition* position,
struct DirectoryEntry* entry,
void** structure)
{
CLUSTER firstcluster;
struct FilesSummary** info = (struct FilesSummary**) structure;
unsigned long dirsize=0, *pdirsize = &dirsize, bytespercluster, labelsinfat;
position = position;
bytespercluster = GetSectorsPerCluster(handle) * BYTESPERSECTOR;
if (!bytespercluster) return FAIL;
if (entry->attribute & FA_LABEL)
return TRUE;
if (IsLFNEntry(entry))
return TRUE;
if (IsDeletedLabel(*entry))
return TRUE;
if (entry->attribute & FA_DIREC)
{
if (IsCurrentDir(*entry)) return TRUE;
if (IsPreviousDir(*entry)) return TRUE;
(*info)->DirectoryCount++;
labelsinfat = GetLabelsInFat(handle);
if (!labelsinfat) return FAIL;
fatmap = CreateBitField(labelsinfat);
if (!fatmap) return FAIL;
firstcluster = GetFirstCluster(entry);
if (!TraverseSubdir(handle, firstcluster, DirSizeGetter,
(void**) &pdirsize, FALSE))
{
return FAIL;
}
DestroyBitfield(fatmap);
AddUlongLong(&(*info)->SizeOfDirectories[0],dirsize);
return TRUE; /* Not taking directories into account when
gathering information on files. */
}
(*info)->TotalFileCount++;
AddUlongLong(&(*info)->TotalSizeofFiles[0],entry->filesize);
AddUlongLong(&(*info)->SizeOfAllFiles[0],
CalculateClustersSize(entry->filesize, bytespercluster));
if (entry->attribute & FA_SYSTEM)
{
(*info)->SystemFileCount++;
AddUlongLong(&(*info)->SizeOfSystemFiles[0],
CalculateClustersSize(entry->filesize, bytespercluster));
}
if (entry->attribute & FA_HIDDEN)
{
(*info)->HiddenFileCount++;
AddUlongLong(&(*info)->SizeOfHiddenFiles[0],
CalculateClustersSize(entry->filesize, bytespercluster));
}
return TRUE;
}