Небольшой классик. Публикую потому, что подустал отсылать его разным людям. Они как сговорились, в третий раз за неделю.

Все на Апи и многое из реестра таскается. Частота проца вычисляется простым способом, котрый я публиковал здесь на сайте. Если вы видели чтото на форуме, не спешите предъявлять авторские права. Год назад я по частям публиковал все это.А писал, уверяю, сам
Этот класс был нужен именно для того, что он делает. Это он выполняет на 99.9%.
Многим он покажется не нужным — спорить не буду, решайте сами.

OS Version
Windows Directory
System Directory
Work Directory
Browser version

Sytem CPU info
Number of processor

Total physical memory
Avail physical memory
Total virtual memory
Avail virtual memory

Video resolution info

System bios version
System Bios date

Local drives info :
A:\ REMOVABLE
C:\ total 2047Mb free 1193Mb FAT FIXED
D:\ total 6644Mb free 3561Mb NTFS FIXED
E:\ CDROM
S:\ total 499Mb free 199Mb FAT FIXED
U:\ total 6644Mb free 3561Mb NTFS FIXED
V:\ total 6644Mb free 3561Mb NTFS FIXED
Y:\ total 2578Mb free 150Mb NTFS FIXED
****

// InfoCollector.h: interface for the CInfoCollector class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_INFOCOLLECTOR_H__231979C2_1C8B_11D6_A208_00C0F6B1F4AB__INCLUDED_)
#define AFX_INFOCOLLECTOR_H__231979C2_1C8B_11D6_A208_00C0F6B1F4AB__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


// from Platform SDK
#define VER_SERVER_NT                       0x80000000
#define VER_WORKSTATION_NT                  0x40000000
#define VER_SUITE_SMALLBUSINESS             0x00000001
#define VER_SUITE_ENTERPRISE                0x00000002
#define VER_SUITE_BACKOFFICE                0x00000004
#define VER_SUITE_COMMUNICATIONS            0x00000008
#define VER_SUITE_TERMINAL                  0x00000010
#define VER_SUITE_SMALLBUSINESS_RESTRICTED  0x00000020
#define VER_SUITE_EMBEDDEDNT                0x00000040
#define VER_SUITE_DATACENTER                0x00000080
#define VER_SUITE_SINGLEUSERTS              0x00000100
#define VER_SUITE_PERSONAL                  0x00000200
#define VER_SUITE_BLADE                     0x00000400

// from Platform SDK
#define VER_NT_WORKSTATION              0x0000001
#define VER_NT_DOMAIN_CONTROLLER        0x0000002
#define VER_NT_SERVER                   0x0000003


class CInfoCollector  
{
public:
    CInfoCollector();
    virtual ~CInfoCollector();

    virtual CString GetOverallInfo();

public:
    // from Platform SDK
    typedef struct _OSVERSIONINFOEX2 {
        DWORD dwOSVersionInfoSize;
        DWORD dwMajorVersion;
        DWORD dwMinorVersion;
        DWORD dwBuildNumber;
        DWORD dwPlatformId;
        TCHAR szCSDVersion[ 128 ];
        WORD wServicePackMajor;
        WORD wServicePackMinor;
        WORD wSuiteMask;
        BYTE wProductType;
        BYTE wReserved;
    } OSVERSIONINFOEX2;
    
protected:
    virtual DWORD CalcCPUSpeed();
    virtual BOOL GetBrowserInfo(CString& szBrowserInfo);
    virtual BOOL GetDirectoriesInfo(CString& szDirsInfo);
    virtual BOOL GetBiosInfo(CString& szBiosInfo);
    virtual BOOL GetVideoResolution(CString& szVideoInfo);
    virtual BOOL GetOSVersion(CString& szVersion);
    virtual BOOL GetMemoryInfo(CString& szMemInfo);
    virtual BOOL GetAllDisksInfo(CString& szDiskInfo);
    virtual BOOL GetCpuInfo(CString& szCpuInfo);

    BOOL CheckWin32Win(CString& szVersion,OSVERSIONINFOEX2& osvi);
    BOOL CheckWin32NT(CString &szVersion,OSVERSIONINFOEX2& osvi,BOOL bEx);
    DWORD CalculateSpeed();
    DWORD TimeStamp();
    BOOL CheckDirectoryAccess(LPCTSTR szPath);
    void GetDiskFree(LPCTSTR pszDrive,DWORD& dwTotal,DWORD& dwFree);
    
    static TCHAR* STR_UNKNOWN;
    static TCHAR* STR_NEWLINE;

    enum {
        WIN32s =     0x1,  
        WIN95 =        0x2,  
        WIN95OSR =    0x4,  
        WIN95OSR2 = 0x8,  
        WIN98 =        0x10, 
        WIN98SE =    0x20, 
        WINME =        0x40, 
        WINNT351 =    0x80, 
        WINNT40 =    0x100,
        WINNT50 =    0x200,
        WINTXP =        0x400,
        WHISTLER =    0x800
    };
    DWORD m_dwOsType;

};

typedef BOOL (WINAPI* PFNGETDISKFREESPACEEX)(LPCTSTR, PULARGE_INTEGER,PULARGE_INTEGER, PULARGE_INTEGER);


inline double find_disk_free(char *path)
{
    double val = 0.0;
    DWORD SectorsPerCluster;        // address of sectors per cluster 
    DWORD BytesPerSector;            // address of bytes per sector 
    DWORD NumberOfFreeClusters;    // address of number of free clusters  
    DWORD TotalNumberOfClusters;     // address of total number of clusters  
    
    LPSTR    pPathPointer = path;
    char    TmpPath[_MAX_PATH];
    int    len = lstrlen(path);
    
    if (len > 3) {
        lstrcpy(TmpPath, path);
        pPathPointer = TmpPath;
        if((TmpPath[0] == '\\' && TmpPath[1] == '\\') ||
            (TmpPath[0] == '/' && TmpPath[1] == '/')) {
            //            Check Network Drive
            pPathPointer = TmpPath+2;
            pPathPointer += strcspn(pPathPointer, "\\/");
            if(*pPathPointer != 0) {
                pPathPointer ++;
                pPathPointer += strcspn(pPathPointer, "\\/");
                if(*pPathPointer != 0) {
                    *(pPathPointer+1) = 0;
                }
            }
            pPathPointer = TmpPath;
        }
        else {
            *(pPathPointer+3) = 0;
        }
    }
    if (len < 3)
        val = (double)1000000.;
    else if (GetDiskFreeSpace(pPathPointer,
        &SectorsPerCluster,
        &BytesPerSector,
        &NumberOfFreeClusters,
        &TotalNumberOfClusters))
        val = (double)NumberOfFreeClusters *
        (double)SectorsPerCluster *
        (double)BytesPerSector;
    
    return val;
}

#endif // !defined(AFX_INFOCOLLECTOR_H__231979C2_1C8B_11D6_A208_00C0F6B1F4AB__INCLUDED_)

// InfoCollector.cpp: implementation of the CInfoCollector class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "InfoHarvest.h"
#include "InfoCollector.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CHAR* CInfoCollector::STR_UNKNOWN = _T("Unknown");
CHAR* CInfoCollector::STR_NEWLINE = _T("\r\n");


CInfoCollector::CInfoCollector()
{
}

CInfoCollector::~CInfoCollector()
{
    
}

BOOL CInfoCollector::GetOSVersion(CString& szVersion)
{
    OSVERSIONINFOEX2 osvi;
    BOOL bEx = FALSE;

   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
    
   if( !(bEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
   {
      // If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO.
      osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
      if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) ) 
         return FALSE;
   }

    
   switch (osvi.dwPlatformId)
   {
    case VER_PLATFORM_WIN32_NT:
        return CheckWin32NT(szVersion,osvi,bEx);        
        
    case VER_PLATFORM_WIN32_WINDOWS:
        return CheckWin32Win(szVersion,osvi);
            
    case VER_PLATFORM_WIN32s:
        szVersion.Format(_T("Microsoft Win 3.1 or Win 3.11"));
        break;
   }
   return TRUE;
}

BOOL CInfoCollector::CheckWin32NT(CString &szVersion,CInfoCollector::OSVERSIONINFOEX2& osvi,BOOL bEx)
{
    CString szTemp = "";
    HKEY hKey;
    TCHAR szProductType[80];
    DWORD dwBufLen;
    BOOL b40 = FALSE;

    
    // Test for the product.
    
    if ( osvi.dwMajorVersion <= 4 )
    {
        szVersion = _T("Microsoft Windows NT ");
        b40 = TRUE;
    }
    
    if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
        szVersion = _T("Microsoft Windows 2000 ");
    
    
    if( bEx )  // Use information from GetVersionEx.
    { 
        // Test for the workstation type.
        if ( osvi.wProductType == VER_NT_WORKSTATION )
        {
            if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
                szVersion = _T("Microsoft Windows XP ");
            
            if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
                szVersion += _T("Home Edition " );
            else
                if( !b40 )
                    szVersion += _T("Professional " );
                else
                    szVersion += _T("Workstation " );
        }
        
        // Test for the server type.
        else if ( osvi.wProductType == VER_NT_SERVER )
        {
            if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
                szVersion = _T("Microsoft Windows .NET ");
            
            if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                szVersion += _T("DataCenter Server " );
            else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                if( osvi.dwMajorVersion == 4 )
                    szVersion += _T("Advanced Server " );
                else
                    szVersion += _T("Enterprise Server " );
                else if ( osvi.wSuiteMask == VER_SUITE_BLADE )
                    szVersion += _T("Web Server " );
                else
                    szVersion += _T("Server " );
        }
    }
    else   // Use the registry on early versions of Windows NT.
    {
        RegOpenKeyEx( HKEY_LOCAL_MACHINE,
            "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
            0, KEY_QUERY_VALUE, &hKey );
        RegQueryValueEx( hKey, "ProductType", NULL, NULL,
            (LPBYTE) szProductType, &dwBufLen);
        RegCloseKey( hKey );
        if ( lstrcmpi( "WINNT", szProductType) == 0 )
            szVersion += _T("Professional " );
        if ( lstrcmpi( "LANMANNT", szProductType) == 0 )
            szVersion += _T("Server " );
        if ( lstrcmpi( "SERVERNT", szProductType) == 0 )
            szVersion += _T("Advanced Server " );
    }
    
    // Display version, service pack (if any), and build number.
    
    if ( osvi.dwMajorVersion <= 4 )
    {
        szTemp.Format("%d.%d %s (Build %d)",
            osvi.dwMajorVersion,
            osvi.dwMinorVersion,
            osvi.szCSDVersion,
            osvi.dwBuildNumber & 0xFFFF);
    }
    else
    { 
        szTemp.Format("%s (Build %d)",
            osvi.szCSDVersion,
            osvi.dwBuildNumber & 0xFFFF);
    }
    szVersion += szTemp;
    return TRUE;
}

BOOL CInfoCollector::CheckWin32Win(CString &szVersion,CInfoCollector::OSVERSIONINFOEX2& osvi)
{
    if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
    {
        szVersion = _T("Microsoft Windows 95 ");
        if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
            szVersion += _T("OSR2 " );
        return TRUE;
    } 
    
    if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
    {
        szVersion = _T("Microsoft Windows 98 ");
        if ( osvi.szCSDVersion[1] == 'A' )
            szVersion += _T("SE " );
        return TRUE;
    } 
    
    if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
    {
        szVersion = _T("Microsoft Windows Millennium Edition ");
        return TRUE;
    } 

    return FALSE;
}

BOOL CInfoCollector::GetCpuInfo(CString& szCpuInfo)
{
    LONG lRes;
    HKEY hKey;
    DWORD dwData;
    TCHAR chData[1024];
    DWORD dwDataSize = sizeof(dwData);
    SYSTEM_INFO s_info;
    CString szTemp;

    lRes = ::RegOpenKeyEx (HKEY_LOCAL_MACHINE,
        _T("Hardware\\Description\\System\\CentralProcessor\\0"),
        0, KEY_QUERY_VALUE, &hKey);

    if(lRes != ERROR_SUCCESS)
        return FALSE;
    
    lRes = ::RegQueryValueEx (hKey, _T("~MHz"), NULL, NULL,
            (LPBYTE)&dwData, &dwDataSize);
    
    if(lRes)
        dwData = CalcCPUSpeed();


    dwDataSize = sizeof(chData);
    lRes = ::RegQueryValueEx (hKey, _T("Identifier"), NULL, NULL,
        (LPBYTE)chData, &dwDataSize);

    if( lRes )
        szCpuInfo.Format (_T("%d MHz "), dwData);
    else
        szCpuInfo.Format(_T("%s %d MHz "), chData,dwData);
        
    lRes += ::RegQueryValueEx (hKey, _T("VendorIdentifier"), NULL, NULL,
            (LPBYTE)chData, &dwDataSize);
    szCpuInfo += chData;
        
    
    lRes += RegCloseKey (hKey);

    GetSystemInfo(&s_info);
    szTemp.Format(_T("\r\nNumber of processor = %u"),s_info.dwNumberOfProcessors);
    szCpuInfo += szTemp;

    
    return TRUE;
}

BOOL CInfoCollector::GetMemoryInfo(CString& szCpuInfo)
{
    MEMORYSTATUS memstat;
    CString szTemp;

    GlobalMemoryStatus(&memstat);

    szCpuInfo.Format(_T("Total physical memory : %u Kb\r\n"),memstat.dwTotalPhys/1024);
    szTemp.Format(_T("Avail physical memory : %u Kb\r\n"),memstat.dwAvailPhys/1024);
    szCpuInfo += szTemp;

    szTemp.Format(_T("Total virtual memory : %u Kb\r\n"),memstat.dwTotalPageFile /1024);
    szCpuInfo += szTemp;

    szTemp.Format(_T("Avail virtual memory : %u Kb"),memstat.dwAvailPageFile/1024);
    szCpuInfo += szTemp;
    return TRUE;
}

BOOL CInfoCollector::GetVideoResolution(CString& szVideoInfo)
{
    HDC hdc = GetDC(NULL);

    szVideoInfo.Format(_T("%ux%u %u bits per pixel"),
                                GetSystemMetrics(SM_CXSCREEN),
                                GetSystemMetrics(SM_CYSCREEN),
                                GetDeviceCaps(hdc,BITSPIXEL));
    ReleaseDC(NULL,hdc);
    
    return TRUE;
}



BOOL CInfoCollector::GetBiosInfo(CString &szBiosInfo)
{
    HKEY hKey;
    LONG lRes;
    TCHAR data[1024];
    DWORD dwDataSize = sizeof(data);
    CString szTemp;

    lRes = ::RegOpenKeyEx (HKEY_LOCAL_MACHINE,
        _T("Hardware\\Description\\System"),
        0, KEY_QUERY_VALUE, &hKey);

    if(lRes != ERROR_SUCCESS)
        return FALSE;
    
    lRes += ::RegQueryValueEx (hKey, _T("SystemBiosVersion"), NULL, NULL,
            (LPBYTE)data, &dwDataSize);
        
    szBiosInfo.Format ("%s \r\n", data);
        
    dwDataSize = sizeof(data);
    lRes += ::RegQueryValueEx (hKey, _T("SystemBiosDate"), NULL, NULL,
            (LPBYTE)data, &dwDataSize);

    szTemp.Format(_T("System Bios date : %s"),data);
    szBiosInfo += szTemp;
        
    
    lRes += RegCloseKey (hKey);

    
    return !lRes;
}


BOOL CInfoCollector::GetAllDisksInfo(CString& szDiskInfo)
{
    TCHAR data[1024];    
    TCHAR* ptr = data; 
    DWORD dwTotal,dwFree;
    CString szTemp;
    UINT type;

    TCHAR szFileSystemNameBuffer[256];
    DWORD dwVolumeSerialNumber;
    DWORD dwFileSystemNameSize=256;

    BOOL bResult;


    szDiskInfo = _T("Local drives info :\r\n");
    GetLogicalDriveStrings(1024,data);

    while(*ptr != TCHAR('\0') )
    {
        type = GetDriveType(ptr);
        if(type != DRIVE_REMOVABLE && type != DRIVE_CDROM)
        {
            GetDiskFree(ptr,dwTotal,dwFree);
            szTemp.Format(_T(" %s total %uMb free %uMb "),ptr,dwTotal,dwFree);

            bResult = GetVolumeInformation(ptr,
                NULL,
                0,
                &dwVolumeSerialNumber,
                NULL,
                NULL,
                szFileSystemNameBuffer,
                dwFileSystemNameSize);
            
            if( bResult )
                szTemp += szFileSystemNameBuffer;
        }
        else
            szTemp.Format(_T(" %s "),ptr);

        szDiskInfo += szTemp;

        switch( type )
        {
        case DRIVE_REMOVABLE:
            szDiskInfo += _T(" REMOVABLE\r\n");
            break;
        case DRIVE_FIXED:
            szDiskInfo += _T(" FIXED\r\n");
            break;
        case DRIVE_REMOTE:     
            szDiskInfo += _T(" NETWORK\r\n");
            break;
        case DRIVE_CDROM:
            szDiskInfo += _T(" CDROM\r\n");
            break;
        case DRIVE_RAMDISK :
            szDiskInfo += _T(" RAMDISK\r\n");
            break;
        default:
            szDiskInfo += _T(" UNKNOWN TYPE\r\n");
        }

        while(*ptr != TCHAR('\0')) 
            ptr++; 
        ptr++;
    }

    
    return  TRUE;
}


CString CInfoCollector::GetOverallInfo()
{
    CString szTemp;
    CString szInfo;
    CWaitCursor cursor;

    szInfo = _T("OS Version = ");
    if(GetOSVersion(szTemp))
        szInfo += szTemp;
    else
        szInfo += STR_UNKNOWN;

    szInfo+=STR_NEWLINE;
    GetDirectoriesInfo(szTemp);
    szInfo+=szTemp;

    szInfo+=_T("\r\nBrowser version = ");
    if(GetBrowserInfo(szTemp))
        szInfo += szTemp;
    else
        szInfo += STR_UNKNOWN;
    

    szInfo+=_T("\r\n\r\nSytem CPU info = ");
    if(GetCpuInfo(szTemp))
        szInfo += szTemp;
    else
        szInfo += STR_UNKNOWN;
    
    GetMemoryInfo(szTemp);
    szInfo += STR_NEWLINE;
    szInfo += STR_NEWLINE;
    szInfo += szTemp;
    
    szInfo += _T("\r\n\r\nVideo resolution info = ");
    if(GetVideoResolution(szTemp))
        szInfo += szTemp;
    else
        szInfo += STR_UNKNOWN;
    
    szInfo += _T("\r\n\r\nSystem bios version = ");
    if(GetBiosInfo(szTemp))
        szInfo += szTemp;
    else
        szInfo += STR_UNKNOWN;

    GetAllDisksInfo(szTemp);
    szInfo += STR_NEWLINE;
    szInfo += STR_NEWLINE;
    szInfo += szTemp;

    return szInfo;
}


BOOL CInfoCollector::GetDirectoriesInfo(CString& szDirsInfo)
{
    TCHAR data[MAX_PATH+1];
    TCHAR* ptr = data;

    szDirsInfo = _T("Windows Directory = ");
    GetWindowsDirectory(data,MAX_PATH+1);

    find_disk_free(data);
    szDirsInfo += data;
    if( !CheckDirectoryAccess(data) )
        szDirsInfo += _T("Write access denied !");

    szDirsInfo += _T("\r\nSystem Directory = ");
    GetSystemDirectory(data,MAX_PATH+1);
    find_disk_free(data);
    szDirsInfo += data;
    if( !CheckDirectoryAccess(data) )
        szDirsInfo+=_T("Write access denied !");
        
    szDirsInfo += _T("\r\nWork Directory = ");
    GetModuleFileName(GetModuleHandle(NULL),data,MAX_PATH+1);
    while(*ptr) ptr++;
    while(*ptr != TCHAR('\\')) ptr--;
    *ptr = TCHAR('\0');

    find_disk_free(data);

    szDirsInfo += data;
    if( !CheckDirectoryAccess(data) )
        szDirsInfo+=_T("Write access denied !");
    
    return TRUE;
}

BOOL CInfoCollector::GetBrowserInfo(CString &szBrowserInfo)
{
    LONG lRes;
    HKEY hKey;
    TCHAR chData[64];
    DWORD dwDataSize = sizeof(chData);
    
    lRes = ::RegOpenKeyEx (HKEY_LOCAL_MACHINE,
        _T("Software\\Microsoft\\Internet Explorer"),
        0, KEY_QUERY_VALUE, &hKey);
    
    if(lRes != ERROR_SUCCESS)
        return FALSE;
    
    lRes += ::RegQueryValueEx (hKey, _T("Version"), NULL, NULL,
        (LPBYTE)chData, &dwDataSize);
    
    szBrowserInfo = chData;
    

    lRes += RegCloseKey (hKey);
    
    return lRes == 0;
}

DWORD CInfoCollector::CalcCPUSpeed()
{
   DWORD dwSpeed = 0;
    
    DWORD dwStartingPriority = GetPriorityClass(GetCurrentProcess());
    SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
    
    dwSpeed = CalculateSpeed();
    
    SetPriorityClass(GetCurrentProcess(), dwStartingPriority);
    
    return dwSpeed;
}


DWORD CInfoCollector::CalculateSpeed()
{
   int    nTimeStart = 0;
   int    nTimeStop = 0;
   DWORD dwStartTicks = 0;
   DWORD dwEndTicks = 0;
   DWORD dwTotalTicks = 0;
   DWORD dwCpuSpeed = 0;
    
    
   nTimeStart = GetTickCount();
    
    dwStartTicks = TimeStamp();
    
   for(;;)
   {
      nTimeStop = GetTickCount();
      if ((nTimeStop - nTimeStart) > 2000)    // one-half second
      {
         dwEndTicks = TimeStamp();
         break;
      }
   }
    
   dwCpuSpeed = (dwEndTicks - dwStartTicks) / (20*100000); // MHz
    
   return (dwCpuSpeed);
}

DWORD CInfoCollector::TimeStamp()
{
   DWORD dwTickVal;
    
   __asm
   {
      _emit 0Fh   // RDTSC
        _emit 31h
        mov   dwTickVal, eax
   }
    
   return dwTickVal;    
}

void CInfoCollector::GetDiskFree(LPCTSTR pszDrive, DWORD &dwTotal, DWORD &dwFree)
{
    PFNGETDISKFREESPACEEX pGetDiskFreeSpaceEx = NULL;
    __int64 i64FreeBytesToCaller;
    __int64 i64TotalBytes;
    __int64 i64FreeBytes;
    DWORD    dwSectPerClust; 
    DWORD    dwBytesPerSect;
    DWORD    dwFreeClusters; 
    DWORD    dwTotalClusters;
    

#ifdef _UNICODE
    pGetDiskFreeSpaceEx = (PFNGETDISKFREESPACEEX)GetProcAddress( GetModuleHandle("kernel32.dll"),
        "GetDiskFreeSpaceExW");
#else
    pGetDiskFreeSpaceEx = (PFNGETDISKFREESPACEEX)GetProcAddress( GetModuleHandle("kernel32.dll"),
        "GetDiskFreeSpaceExA");
#endif
    
    if (pGetDiskFreeSpaceEx)
    {
        pGetDiskFreeSpaceEx (pszDrive,
            (PULARGE_INTEGER)&i64FreeBytesToCaller,
            (PULARGE_INTEGER)&i64TotalBytes,
            (PULARGE_INTEGER)&i64FreeBytes);

        dwTotal = DWORD(i64TotalBytes / (1024*1024));
        dwFree =  DWORD(i64FreeBytesToCaller / (1024*1024));
    }
    else 
    {
        GetDiskFreeSpace (pszDrive, 
            &dwSectPerClust, 
            &dwBytesPerSect,
            &dwFreeClusters, 
            &dwTotalClusters);

        dwTotal = DWORD((__int64(dwTotalClusters) * dwSectPerClust * dwBytesPerSect)/(1024*1024));
        dwFree = DWORD((__int64(dwFreeClusters) * dwSectPerClust * dwBytesPerSect)/(1024*1024));
        
    }
}

BOOL CInfoCollector::CheckDirectoryAccess(LPCTSTR szPath)
{
    TCHAR* szPre = "mad";  
    TCHAR szFileName[MAX_PATH+1];
    HANDLE hFile = NULL;
    int iResult = 0;

    GetTempFileName(szPath,szPre,0,szFileName);

    hFile = CreateFile(szFileName,
        GENERIC_WRITE |GENERIC_READ,
        0,NULL,
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL,
        NULL);

    if(hFile == INVALID_HANDLE_VALUE)
        return FALSE;

    iResult += (int)!CloseHandle(hFile);
    iResult += (int)!DeleteFile(szFileName);    

    return  !iResult;
}