DriveVolume Class Reference

#include <DriveVolume.h>

Collaboration diagram for DriveVolume:

Public Member Functions
	DriveVolume ()
	~DriveVolume ()
bool	Open (wstring Name)
void	Close (void)
bool	ObtainInfo (void)
bool	GetBitmap (void)
bool	BuildFileList (bool &QuitMonitor, double &Progress)
bool	IsClusterUsed (uint64 Cluster)
void	SetClusterUsed (uint64 Cluster, bool Used)
DISK_GEOMETRY	GetGeometry (void)
VolumeInfo	GetVolumeInfo (void)
wstring	GetRootPath (void)
bool	Scan (ScanCallback Callback, void *UserData)
wstring &	GetDBDir (uint32 Indice)
uint32	GetDBDirCount (void)
FileInfo &	GetDBFile (uint32 Indice)
uint32	GetDBFileCount (void)
uint32	RemoveDBFile (uint32 Indice)
bool	MoveFileDumb (uint32 FileIndice, uint64 NewLCN)
bool	FindFreeRange (uint64 StartLCN, uint64 ReqLength, uint64 &LCNResult)

Private Member Functions
bool	ScanDirectory (wstring DirPrefix, ScanCallback Callback, void *UserData)
bool	ShouldProcess (FileAttr Attr)
bool	GetClusterInfo (FileInfo &Info, HANDLE &HandleResult)

Private Attributes
VolumeInfo	VolInfo
FileList	Files
vector< wstring >	Directories
wstring	RootPath
HANDLE	Handle
DISK_GEOMETRY	Geometry
uint32 *	BitmapDetail

Friends
bool	BuildDBCallback (FileInfo &Info, HANDLE &FileHandle, void *UserData)

Detailed Description

Definition at line 89 of file DriveVolume.h.

Constructor & Destructor Documentation

DriveVolume()

DriveVolume::DriveVolume

(

)

Definition at line 4 of file DriveVolume.cpp.

{
    Handle = INVALID_HANDLE_VALUE;
    BitmapDetail = NULL;
    return;
}

~DriveVolume()

DriveVolume::~DriveVolume

(

)

Definition at line 12 of file DriveVolume.cpp.

{
    Close ();
    Directories.clear ();
    Files.clear ();
    return;
}

Member Function Documentation

BuildFileList()

bool DriveVolume::BuildFileList	(	bool &	QuitMonitor,
		double &	Progress
	)

Definition at line 289 of file DriveVolume.cpp.

{
    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);
}

Referenced by Defragment::Start().

Close()

void DriveVolume::Close

(

void

)

Definition at line 21 of file DriveVolume.cpp.

{
    if (Handle != INVALID_HANDLE_VALUE)
    {
        CloseHandle (Handle);
        Handle = INVALID_HANDLE_VALUE;
    }

    if (BitmapDetail != NULL)
    {
        free (BitmapDetail);
        BitmapDetail = NULL;
    }

    return;
}

Referenced by Defragment::Start(), Defragment::~Defragment(), and ~DriveVolume().

FindFreeRange()

bool DriveVolume::FindFreeRange	(	uint64	StartLCN,
		uint64	ReqLength,
		uint64 &	LCNResult
	)

Definition at line 621 of file DriveVolume.cpp.

{
    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);
}

Referenced by Defragment::Start().

GetBitmap()

bool DriveVolume::GetBitmap

(

void

)

Definition at line 172 of file DriveVolume.cpp.

{
    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);
}

Referenced by Defragment::Start().

GetClusterInfo()

bool DriveVolume::GetClusterInfo ( FileInfo &  Info, HANDLE &  HandleResult  )

private

Definition at line 484 of file DriveVolume.cpp.

{
    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 = CreateFileW
    (
        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

    Info.Fragments.clear ();
    for (uint64 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);
}

Referenced by MoveFileDumb(), and ScanDirectory().

GetDBDir()

wstring & DriveVolume::GetDBDir

(

uint32

Indice

)

Definition at line 334 of file DriveVolume.cpp.

{
    return (Directories[Indice]);
}

Referenced by GetClusterInfo(), MoveFileDumb(), ScanDirectory(), and Defragment::Start().

GetDBDirCount()

uint32 DriveVolume::GetDBDirCount

(

void

)

Definition at line 340 of file DriveVolume.cpp.

{
    return (Directories.size());
}

Referenced by Defragment::Start().

GetDBFile()

FileInfo & DriveVolume::GetDBFile

(

uint32

Indice

)

Definition at line 346 of file DriveVolume.cpp.

{
    return (Files[Indice]);
}

Referenced by MoveFileDumb(), and Defragment::Start().

GetDBFileCount()

uint32 DriveVolume::GetDBFileCount

(

void

)

Definition at line 352 of file DriveVolume.cpp.

{
    return (Files.size());
}

Referenced by RemoveDBFile(), and Defragment::Start().

GetGeometry()

DISK_GEOMETRY DriveVolume::GetGeometry ( void  )

inline

Definition at line 108 of file DriveVolume.h.

{ return (Geometry); }

GetRootPath()

wstring DriveVolume::GetRootPath ( void  )

inline

Definition at line 111 of file DriveVolume.h.

{ return (RootPath); }

Referenced by GetDefragTitle(), and Defragment::Start().

GetVolumeInfo()

VolumeInfo DriveVolume::GetVolumeInfo ( void  )

inline

Definition at line 109 of file DriveVolume.h.

{ return (VolInfo); }

Referenced by BuildFileList(), SetReportInfo(), and Defragment::Start().

IsClusterUsed()

bool DriveVolume::IsClusterUsed

(

uint64

Cluster

)

Definition at line 261 of file DriveVolume.cpp.

{
    return ((BitmapDetail[Cluster / 32] & (1 << (Cluster % 32))) ? true : false);
    //return (BitmapDetail[Cluster].Allocated);
}

Referenced by FindFreeRange().

MoveFileDumb()

bool DriveVolume::MoveFileDumb	(	uint32	FileIndice,
		uint64	NewLCN
	)

Definition at line 666 of file DriveVolume.cpp.

{
    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 = CreateFileW
    (
        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);
}

Referenced by Defragment::Start().

ObtainInfo()

bool DriveVolume::ObtainInfo

(

void

)

Definition at line 113 of file DriveVolume.cpp.

{
    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 = GetDiskFreeSpaceW
    (
        RootPath.c_str(),
        &SectorsPerCluster,
        &BytesPerSector,
        &FreeClusters,
        &TotalClusters
    );

    // Failed? Weird.
    if (!Result)
        return (false);

    VolInfo.ClusterSize = SectorsPerCluster * BytesPerSector;

    Result = GetDiskFreeSpaceExW
    (
        RootPath.c_str(),
        (PULARGE_INTEGER)&nan,
        (PULARGE_INTEGER)&VolInfo.TotalBytes,
        (PULARGE_INTEGER)&VolInfo.FreeBytes
    );

    return (true);
}

Referenced by Defragment::Start().

Open()

bool DriveVolume::Open

(

wstring

Name

)

Definition at line 42 of file DriveVolume.cpp.

{
    wchar_t FileName[100];
    bool ReturnVal;

    swprintf (FileName, L"\\\\.\\%s", Name.c_str());
    RootPath = Name.c_str();
    RootPath += L"\\";

    Handle = CreateFileW
    (
        FileName,
        MAXIMUM_ALLOWED,                          // access
        FILE_SHARE_READ | FILE_SHARE_WRITE,       // share type
        NULL,                                     // security descriptor
        OPEN_EXISTING,                            // open type
        0,                                     // 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 = GetVolumeInformationW
        (
            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);
}

Referenced by Defragment::Defragment().

RemoveDBFile()

uint32 DriveVolume::RemoveDBFile

(

uint32

Indice

)

Definition at line 358 of file DriveVolume.cpp.

{
    vector<FileInfo>::iterator it;

    it = Files.begin() + Indice;
    Files.erase (it);
    return (GetDBFileCount());
}

Scan()

bool DriveVolume::Scan	(	ScanCallback	Callback,
		void *	UserData
	)

ScanDirectory()

bool DriveVolume::ScanDirectory ( wstring  DirPrefix, ScanCallback  Callback, void *  UserData  )

private

Definition at line 368 of file DriveVolume.cpp.

{
    WIN32_FIND_DATAW FindData;
    HANDLE          FindHandle;
    wstring          SearchString;
    uint32          DirIndice;

    DirIndice = Directories.size() - 1;

    SearchString = DirPrefix;
    SearchString += L"*.*";
    ZeroMemory (&FindData, sizeof (FindData));
    FindHandle = FindFirstFileW (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 (size_t 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 (FindNextFileW (FindHandle, &FindData) == TRUE);

    FindClose (FindHandle);
    return (false);
}

Referenced by BuildFileList().

SetClusterUsed()

void DriveVolume::SetClusterUsed	(	uint64	Cluster,
		bool	Used
	)

Definition at line 268 of file DriveVolume.cpp.

{
    if (Used)
        BitmapDetail[Cluster / 32] |= (1 << (Cluster % 32));
    else
        BitmapDetail[Cluster / 32] &= ~(1 << (Cluster % 32));

    return;
}

Referenced by MoveFileDumb().

ShouldProcess()

bool DriveVolume::ShouldProcess ( FileAttr  Attr )

private

Definition at line 470 of file DriveVolume.cpp.

{
    if (Attr.Offline == 1  ||  Attr.Reparse == 1  ||  Attr.Temporary == 1)
    {
        return (false);
    }

    return (true);
}

Referenced by ScanDirectory().

Friends And Related Function Documentation

BuildDBCallback

bool BuildDBCallback ( FileInfo &  Info, HANDLE &  FileHandle, void *  UserData  )

friend

Definition at line 316 of file DriveVolume.cpp.

{
    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);
}

Referenced by BuildFileList().

Member Data Documentation

BitmapDetail

uint32* DriveVolume::BitmapDetail

private

Definition at line 153 of file DriveVolume.h.

Referenced by Close(), DriveVolume(), GetBitmap(), IsClusterUsed(), and SetClusterUsed().

Directories

vector<wstring> DriveVolume::Directories

private

Definition at line 149 of file DriveVolume.h.

Referenced by BuildFileList(), GetDBDir(), GetDBDirCount(), ScanDirectory(), and ~DriveVolume().

Files

FileList DriveVolume::Files

private

Definition at line 148 of file DriveVolume.h.

Referenced by BuildDBCallback(), BuildFileList(), GetDBFile(), GetDBFileCount(), MoveFileDumb(), RemoveDBFile(), and ~DriveVolume().

Geometry

DISK_GEOMETRY DriveVolume::Geometry

private

Definition at line 152 of file DriveVolume.h.

Referenced by ObtainInfo().

Handle

HANDLE DriveVolume::Handle

private

Definition at line 151 of file DriveVolume.h.

Referenced by GetClusterInfo(), and ScanDirectory().

RootPath

wstring DriveVolume::RootPath

private

Definition at line 150 of file DriveVolume.h.

Referenced by BuildFileList(), ObtainInfo(), and Open().

VolInfo

VolumeInfo DriveVolume::VolInfo

private

Definition at line 147 of file DriveVolume.h.

Referenced by FindFreeRange(), GetBitmap(), ObtainInfo(), and Open().

---

The documentation for this class was generated from the following files:

• modules/rosapps/applications/fraginator/DriveVolume.h
• modules/rosapps/applications/fraginator/DriveVolume.cpp