Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-29 10:35:28 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/rosapps/fraginator/DriveVolume.cpp
KJK::Hyperion 018539280c - deleted temporary files, generated files, binaries 
- migrated project files to Visual C++ 2005 Express - the latest, the best, for free
 - converted to an Unicode application

svn path=/trunk/; revision=21432
2006-04-01 15:02:38 +00:00

806 lines
21 KiB
C++
Raw Blame History

#include "DriveVolume.h"
DriveVolume::DriveVolume ()
{
Handle = INVALID_HANDLE_VALUE;
BitmapDetail = NULL;
return;
}
DriveVolume::~DriveVolume ()
{
Close ();
Directories.clear ();
Files.clear ();
return;
}
void DriveVolume::Close (void)
{
if (Handle != INVALID_HANDLE_VALUE)
{
CloseHandle (Handle);
Handle = INVALID_HANDLE_VALUE;
}
if (BitmapDetail != NULL)
{
free (BitmapDetail);
BitmapDetail = NULL;
}
return;
}
// "Name" should be the drive letter followed by a colon. ie, "c:"
// It's a string to allow for further expansion (ie, defragging over the network?)
// or some other baloney reason
bool DriveVolume::Open (wstring Name)
{
wchar_t FileName[100];
bool ReturnVal;
swprintf (FileName, L"\\\\.\\%s", Name.c_str());
RootPath = Name.c_str();
RootPath += L"\\";
Handle = CreateFile
(
FileName,
MAXIMUM_ALLOWED, // access
FILE_SHARE_READ | FILE_SHARE_WRITE, // share type
NULL, // security descriptor
OPEN_EXISTING, // open type
NULL, // attributes (none)
NULL // template
);
if (Handle == INVALID_HANDLE_VALUE)
ReturnVal = false;
else
{
wchar_t VolName[64];
DWORD VolSN;
DWORD VolMaxFileLen;
DWORD FSFlags;
wchar_t FSName[64];
BOOL Result;
ReturnVal = true;
Result = GetVolumeInformation
(
RootPath.c_str(),
VolName,
sizeof (VolName),
&VolSN,
&VolMaxFileLen,
&FSFlags,
FSName,
sizeof (FSName)
);
if (Result)
{
wchar_t SerialText[10];
VolInfo.FileSystem = FSName;
VolInfo.MaxNameLen = VolMaxFileLen;
VolInfo.Name = VolName;
swprintf (SerialText, L"%x-%x", (VolSN & 0xffff0000) >> 16,
VolSN & 0x0000ffff);
wcsupr (SerialText);
VolInfo.Serial = SerialText;
}
else
{
VolInfo.FileSystem = L"(Unknown)";
VolInfo.MaxNameLen = 255;
VolInfo.Name = L"(Unknown)";
VolInfo.Serial = L"(Unknown)";
}
}
return (ReturnVal);
}
bool DriveVolume::ObtainInfo (void)
{
BOOL Result;
DWORD BytesGot;
uint64 nan;
BytesGot = 0;
ZeroMemory (&Geometry, sizeof (Geometry));
Result = DeviceIoControl
(
Handle,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL,
0,
&Geometry,
sizeof (Geometry),
&BytesGot,
NULL
);
// Call failed? Aww :(
if (!Result)
return (false);
// Get cluster size
DWORD SectorsPerCluster;
DWORD BytesPerSector;
DWORD FreeClusters;
DWORD TotalClusters;
Result = GetDiskFreeSpace
(
RootPath.c_str(),
&SectorsPerCluster,
&BytesPerSector,
&FreeClusters,
&TotalClusters
);
// Failed? Weird.
if (!Result)
return (false);
VolInfo.ClusterSize = SectorsPerCluster * BytesPerSector;
Result = GetDiskFreeSpaceEx
(
RootPath.c_str(),
(PULARGE_INTEGER)&nan,
(PULARGE_INTEGER)&VolInfo.TotalBytes,
(PULARGE_INTEGER)&VolInfo.FreeBytes
);
return (true);
}
// Get bitmap, several clusters at a time ...
#define CLUSTERS 4096
bool DriveVolume::GetBitmap (void)
{
STARTING_LCN_INPUT_BUFFER StartingLCN;
VOLUME_BITMAP_BUFFER *Bitmap = NULL;
uint32 BitmapSize;
DWORD BytesReturned;
BOOL Result;
StartingLCN.StartingLcn.QuadPart = 0;
// Allocate buffer
// Call FSCTL_GET_VOLUME_BITMAP once with a very small buffer
// This will leave the total number of clusters in Bitmap->BitmapSize and we can
// then correctly allocate based off that
// I suppose this won't work if your drive has only 40 clusters on it or so :)
BitmapSize = sizeof (VOLUME_BITMAP_BUFFER) + 4;
Bitmap = (VOLUME_BITMAP_BUFFER *) malloc (BitmapSize);
Result = DeviceIoControl
(
Handle,
FSCTL_GET_VOLUME_BITMAP,
&StartingLCN,
sizeof (StartingLCN),
Bitmap,
BitmapSize,
&BytesReturned,
NULL
);
// Bad result?
if (Result == FALSE && GetLastError () != ERROR_MORE_DATA)
{
//wprintf ("\nDeviceIoControl returned false, GetLastError() was not ERROR_MORE_DATA\n");
free (Bitmap);
return (false);
}
// Otherwise, we're good
BitmapSize = sizeof (VOLUME_BITMAP_BUFFER) + (Bitmap->BitmapSize.QuadPart / 8) + 1;
Bitmap = (VOLUME_BITMAP_BUFFER *) realloc (Bitmap, BitmapSize);
Result = DeviceIoControl
(
Handle,
FSCTL_GET_VOLUME_BITMAP,
&StartingLCN,
sizeof (StartingLCN),
Bitmap,
BitmapSize,
&BytesReturned,
NULL
);
DWORD LastError = GetLastError ();
if (Result == FALSE)
{
wprintf (L"\nCouldn't properly read volume bitmap\n");
free (Bitmap);
return (false);
}
// Convert to a L'quick use' bitmap
//const int BitShift[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
VolInfo.ClusterCount = Bitmap->BitmapSize.QuadPart;
if (BitmapDetail != NULL)
free (BitmapDetail);
BitmapDetail = (uint32 *) malloc (sizeof(uint32) * (1 + (VolInfo.ClusterCount / 32)));
memcpy (BitmapDetail, Bitmap->Buffer, sizeof(uint32) * (1 + (VolInfo.ClusterCount / 32)));
/*
BitmapDetail = (Cluster *) malloc (VolInfo.ClusterCount * sizeof (Cluster));
for (uint64 i = 0; i < VolInfo.ClusterCount; i++)
{
if (Bitmap->Buffer[i / 8] & BitShift[i % 8])
BitmapDetail[i].Allocated = true;
else
BitmapDetail[i].Allocated = false;
}
*/
free (Bitmap);
return (true);
}
bool DriveVolume::IsClusterUsed (uint64 Cluster)
{
return ((BitmapDetail[Cluster / 32] & (1 << (Cluster % 32))) ? true : false);
//return (BitmapDetail[Cluster].Allocated);
}
void DriveVolume::SetClusterUsed (uint64 Cluster, bool Used)
{
if (Used)
BitmapDetail[Cluster / 32] |= (1 << (Cluster % 32));
else
BitmapDetail[Cluster / 32] &= ~(1 << (Cluster % 32));
return;
}
typedef struct
{
DriveVolume *Volume;
double *Percent;
bool *QuitMonitor;
uint64 ClusterCount;
uint64 ClusterProgress;
} BuildDBInfo;
bool DriveVolume::BuildFileList (bool &QuitMonitor, double &Percent)
{
BuildDBInfo Info;
Files.clear ();
Directories.clear ();
Directories.push_back (RootPath);
Info.Volume = this;
Info.QuitMonitor = &QuitMonitor;
Info.ClusterCount = (GetVolumeInfo().TotalBytes - GetVolumeInfo().FreeBytes) / (uint64)GetVolumeInfo().ClusterSize;
Info.ClusterProgress = 0;
Info.Percent = &Percent;
ScanDirectory (RootPath, BuildDBCallback, &Info);
if (QuitMonitor == true)
{
Directories.resize (0);
Files.resize (0);
}
return (true);
}
// UserData = pointer to BuildDBInfo instance
bool BuildDBCallback (FileInfo &Info, HANDLE &FileHandle, void *UserData)
{
BuildDBInfo *DBInfo = (BuildDBInfo *) UserData;
DriveVolume *Vol = DBInfo->Volume;
Vol->Files.push_back (Info);
if (*(DBInfo->QuitMonitor) == true)
return (false);
DBInfo->ClusterProgress += (uint64)Info.Clusters;
*(DBInfo->Percent) =
((double)DBInfo->ClusterProgress / (double)DBInfo->ClusterCount) * 100.0f;
return (true);
}
wstring &DriveVolume::GetDBDir (uint32 Indice)
{
return (Directories[Indice]);
}
uint32 DriveVolume::GetDBDirCount (void)
{
return (Directories.size());
}
FileInfo &DriveVolume::GetDBFile (uint32 Indice)
{
return (Files[Indice]);
}
uint32 DriveVolume::GetDBFileCount (void)
{
return (Files.size());
}
uint32 DriveVolume::RemoveDBFile (uint32 Indice)
{
vector<FileInfo>::iterator it;
it = Files.begin() + Indice;
Files.erase (it);
return (GetDBFileCount());
}
bool DriveVolume::ScanDirectory (wstring DirPrefix, ScanCallback Callback, void *UserData)
{
WIN32_FIND_DATA FindData;
HANDLE FindHandle;
wstring SearchString;
uint32 DirIndice;
DirIndice = Directories.size() - 1;
SearchString = DirPrefix;
SearchString += L"*.*";
ZeroMemory (&FindData, sizeof (FindData));
FindHandle = FindFirstFile (SearchString.c_str(), &FindData);
if (FindHandle == INVALID_HANDLE_VALUE)
return (false);
do
{
FileInfo Info;
HANDLE Handle;
bool CallbackResult;
Handle = INVALID_HANDLE_VALUE;
// First copy over the easy stuff.
Info.Name = FindData.cFileName;
// DonLL't ever include '.L' and '..'
if (Info.Name == L"." || Info.Name == L"..")
continue;
//Info.FullName = DirPrefix + Info.Name;
Info.Size = (uint64)FindData.nFileSizeLow + ((uint64)FindData.nFileSizeHigh << (uint64)32);
Info.DirIndice = DirIndice;
Info.Attributes.Archive = (FindData.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) ? 1 : 0;
Info.Attributes.Compressed = (FindData.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) ? 1 : 0;
Info.Attributes.Directory = (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
Info.Attributes.Encrypted = (FindData.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) ? 1 : 0;
Info.Attributes.Hidden = (FindData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) ? 1 : 0;
Info.Attributes.Normal = (FindData.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) ? 1 : 0;
Info.Attributes.Offline = (FindData.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) ? 1 : 0;
Info.Attributes.ReadOnly = (FindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? 1 : 0;
Info.Attributes.Reparse = (FindData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) ? 1 : 0;
Info.Attributes.Sparse = (FindData.dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) ? 1 : 0;
Info.Attributes.System = (FindData.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) ? 1 : 0;
Info.Attributes.Temporary = (FindData.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) ? 1 : 0;
Info.Attributes.AccessDenied = 0;
Info.Attributes.Unmovable = 0;
Info.Attributes.Process = 1;
Info.Clusters = 0;
if (GetClusterInfo (Info, Handle))
{
uint64 TotalClusters = 0;
for (int i = 0; i < Info.Fragments.size(); i++)
{
TotalClusters += Info.Fragments[i].Length;
}
Info.Clusters = TotalClusters;
}
else
{
Info.Attributes.Unmovable = 1;
Info.Attributes.Process = 0;
}
if (Info.Attributes.Process == 1)
Info.Attributes.Process = ShouldProcess (Info.Attributes) ? 1 : 0;
// Run the user-defined callback function
CallbackResult = Callback (Info, Handle, UserData);
if (Handle != INVALID_HANDLE_VALUE)
CloseHandle (Handle);
if (!CallbackResult)
break;
// If directory, perform recursion
if (Info.Attributes.Directory == 1)
{
wstring Dir;
Dir = GetDBDir (Info.DirIndice);
Dir += Info.Name;
Dir += L"\\";
Directories.push_back (Dir);
ScanDirectory (Dir, Callback, UserData);
}
} while (FindNextFile (FindHandle, &FindData) == TRUE);
FindClose (FindHandle);
return (false);
}
bool DriveVolume::ShouldProcess (FileAttr Attr)
{
if (Attr.Offline == 1 || Attr.Reparse == 1 || Attr.Temporary == 1)
{
return (false);
}
return (true);
}
// Gets info on a file and returns a valid handle for read/write access
// Name, FullName, Clusters, Attributes, and Size should already be filled out.
// This function fills in the Fragments vector
bool DriveVolume::GetClusterInfo (FileInfo &Info, HANDLE &HandleResult)
{
BOOL Result;
HANDLE Handle;
wstring FullName;
BY_HANDLE_FILE_INFORMATION FileInfo;
Info.Fragments.resize (0);
/*
if (Info.Attributes.Directory == 1)
return (false);
*/
FullName = GetDBDir (Info.DirIndice) + Info.Name;
Handle = CreateFile
(
FullName.c_str(),
0, //GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
(Info.Attributes.Directory == 1) ? FILE_FLAG_BACKUP_SEMANTICS : 0,
NULL
);
if (Handle == INVALID_HANDLE_VALUE)
{
LPVOID lpMsgBuf;
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf, 0, NULL );
Info.Attributes.AccessDenied = 1;
LocalFree( lpMsgBuf );
return (false);
}
ZeroMemory (&FileInfo, sizeof (FileInfo));
Result = GetFileInformationByHandle (Handle, &FileInfo);
if (Result == FALSE)
{
Info.Attributes.AccessDenied = 1;
wprintf (L"GetFileInformationByHandle ('%s%s') failed\n", GetDBDir (Info.DirIndice).c_str(),
Info.Name.c_str());
CloseHandle (Handle);
return (false);
}
// Get cluster allocation information
STARTING_VCN_INPUT_BUFFER StartingVCN;
RETRIEVAL_POINTERS_BUFFER *Retrieval;
uint64 RetSize;
uint64 Extents;
DWORD BytesReturned;
// Grab info one extent at a time, until it's done grabbing all the extent data
// Yeah, well it doesn't give us a way to ask L"how many extents?" that I know of ...
// btw, the Extents variable tends to only reflect memory usage, so when we have
// all the extents we look at the structure Win32 gives us for the REAL count!
Extents = 10;
Retrieval = NULL;
RetSize = 0;
StartingVCN.StartingVcn.QuadPart = 0;
do
{
Extents *= 2;
RetSize = sizeof (RETRIEVAL_POINTERS_BUFFER) + ((Extents - 1) * sizeof (LARGE_INTEGER) * 2);
if (Retrieval != NULL)
Retrieval = (RETRIEVAL_POINTERS_BUFFER *) realloc (Retrieval, RetSize);
else
Retrieval = (RETRIEVAL_POINTERS_BUFFER *) malloc (RetSize);
Result = DeviceIoControl
(
Handle,
FSCTL_GET_RETRIEVAL_POINTERS,
&StartingVCN,
sizeof (StartingVCN),
Retrieval,
RetSize,
&BytesReturned,
NULL
);
if (Result == FALSE)
{
if (GetLastError() != ERROR_MORE_DATA)
{
Info.Clusters = 0;
Info.Attributes.AccessDenied = 1;
Info.Attributes.Process = 0;
Info.Fragments.clear ();
CloseHandle (Handle);
free (Retrieval);
return (false);
}
Extents++;
}
} while (Result == FALSE);
// Readjust extents, as it only reflects how much memory was allocated and may not
// be accurate
Extents = Retrieval->ExtentCount;
// Ok, we have the info. Now translate it. hrmrmr
int i;
Info.Fragments.clear ();
for (i = 0; i < Extents; i++)
{
Extent Add;
Add.StartLCN = Retrieval->Extents[i].Lcn.QuadPart;
if (i != 0)
Add.Length = Retrieval->Extents[i].NextVcn.QuadPart - Retrieval->Extents[i - 1].NextVcn.QuadPart;
else
Add.Length = Retrieval->Extents[i].NextVcn.QuadPart - Retrieval->StartingVcn.QuadPart;
Info.Fragments.push_back (Add);
}
free (Retrieval);
HandleResult = Handle;
return (true);
}
bool DriveVolume::FindFreeRange (uint64 StartLCN, uint64 ReqLength, uint64 &LCNResult)
{
uint64 Max;
uint64 i;
uint64 j;
// Make sure we don't spill over our array
Max = VolInfo.ClusterCount - ReqLength;
for (i = StartLCN; i < Max; i++)
{
bool Found = true;
// First check the first cluster
if (IsClusterUsed (i))
Found = false;
else
// THen check the last cluster
if (IsClusterUsed (i + ReqLength - 1))
Found = false;
else
// Check the whole darn range.
for (j = (i + 1); j < (i + ReqLength - 2); j++)
{
if (IsClusterUsed (j) == true)
{
Found = false;
break;
}
}
if (!Found)
continue;
else
{
LCNResult = i;
return (true);
}
}
return (false);
}
// btw we have to move each fragment of the file, as per the Win32 API
bool DriveVolume::MoveFileDumb (uint32 FileIndice, uint64 NewLCN)
{
bool ReturnVal = false;
FileInfo Info;
HANDLE FileHandle;
wstring FullName;
MOVE_FILE_DATA MoveData;
uint64 CurrentLCN;
uint64 CurrentVCN;
// Set up variables
Info = GetDBFile (FileIndice);
FullName = GetDBDir (Info.DirIndice);
FullName += Info.Name;
CurrentLCN = NewLCN;
CurrentVCN = 0;
/*
if (Info.Attributes.Directory == 1)
{
//
}
*/
// Open file
FileHandle = CreateFile
(
FullName.c_str (),
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
(Info.Attributes.Directory == 1) ? FILE_FLAG_BACKUP_SEMANTICS : 0,
NULL
);
if (FileHandle == INVALID_HANDLE_VALUE)
{
//
LPVOID lpMsgBuf;
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf, 0, NULL );
LocalFree (lpMsgBuf);
//
ReturnVal = false;
}
else
{
ReturnVal = true; // innocent until proven guilty ...
for (uint32 i = 0; i < Info.Fragments.size(); i++)
{
BOOL Result;
DWORD BytesReturned;
//wprintf (L"%3u", i);
MoveData.ClusterCount = Info.Fragments[i].Length;
MoveData.StartingLcn.QuadPart = CurrentLCN;
MoveData.StartingVcn.QuadPart = CurrentVCN;
MoveData.FileHandle = FileHandle;
/*
wprintf (L"\n");
wprintf (L"StartLCN: %I64u\n", MoveData.StartingLcn.QuadPart);
wprintf (L"StartVCN: %I64u\n", MoveData.StartingVcn.QuadPart);
wprintf (L"Clusters: %u (%I64u-%I64u --> %I64u-%I64u)\n", MoveData.ClusterCount,
Info.Fragments[i].StartLCN,
Info.Fragments[i].StartLCN + MoveData.ClusterCount,
MoveData.StartingLcn.QuadPart,
MoveData.StartingLcn.QuadPart + MoveData.ClusterCount - 1);
wprintf (L"\n");
*/
Result = DeviceIoControl
(
Handle,
FSCTL_MOVE_FILE,
&MoveData,
sizeof (MoveData),
NULL,
0,
&BytesReturned,
NULL
);
//wprintf (L"\b\b\b");
if (Result == FALSE)
{
//
LPVOID lpMsgBuf;
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf, 0, NULL );
LocalFree( lpMsgBuf );
//
ReturnVal = false;
goto FinishUp; // yeah, bite me
}
// Ok good. Now update our drive bitmap and file infos.
uint64 j;
for (j = 0;
j < Info.Fragments[i].Length;
j++)
{
SetClusterUsed (Info.Fragments[i].StartLCN + j, false);
SetClusterUsed (CurrentLCN + j, true);
//BitmapDetail[Info.Fragments[i].StartLCN + j].Allocated = false;
//BitmapDetail[CurrentLCN + j].Allocated = true;
}
CurrentLCN += Info.Fragments[i].Length;
CurrentVCN += Info.Fragments[i].Length;
}
// Update file info either way
FinishUp:
CloseHandle (FileHandle);
FileHandle = INVALID_HANDLE_VALUE;
GetClusterInfo (Files[FileIndice], FileHandle);
CloseHandle (FileHandle);
}
return (ReturnVal);
}
Reference in a new issue View git blame Copy permalink