static void test_GetDiskFreeSpaceW(void)
{
BOOL ret;
DWORD sectors_per_cluster, bytes_per_sector, free_clusters, total_clusters;
WCHAR drive[] = {'?',':','\\',0};
DWORD logical_drives;
static const WCHAR empty_pathW[] = { 0 };
static const WCHAR root_pathW[] = { '\\', 0 };
static const WCHAR unix_style_root_pathW[] = { '/', 0 };
ret = GetDiskFreeSpaceW(NULL, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
{
win_skip("GetDiskFreeSpaceW is not available\n");
return;
}
ok(ret, "GetDiskFreeSpaceW error %d\n", GetLastError());
ret = GetDiskFreeSpaceW(empty_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
"GetDiskFreeSpaceW(\"\"): ret=%d GetLastError=%d\n",
ret, GetLastError());
ret = GetDiskFreeSpaceW(root_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceW(\"\") error %d\n", GetLastError());
ret = GetDiskFreeSpaceW(unix_style_root_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceW error %d\n", GetLastError());
logical_drives = GetLogicalDrives();
ok(logical_drives != 0, "GetLogicalDrives error %d\n", GetLastError());
for (drive[0] = 'A'; drive[0] <= 'Z'; drive[0]++)
{
UINT drivetype = GetDriveTypeW(drive);
/* Skip floppy drives because NT4 pops up a MessageBox if no floppy is present */
if (drivetype != DRIVE_REMOVABLE && drivetype != DRIVE_NO_ROOT_DIR)
{
ret = GetDiskFreeSpaceW(drive, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (!(logical_drives & 1))
ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
"GetDiskFreeSpaceW(%c): ret=%d GetLastError=%d\n",
drive[0], ret, GetLastError());
else
ok( ret ||
GetLastError() == ERROR_NOT_READY ||
GetLastError() == ERROR_INVALID_FUNCTION ||
GetLastError() == ERROR_PATH_NOT_FOUND ||
GetLastError() == ERROR_REQUEST_ABORTED ||
GetLastError() == ERROR_UNRECOGNIZED_VOLUME,
"GetDiskFreeSpaceW(%c): ret=%d GetLastError=%d\n",
drive[0], ret, GetLastError());
}
logical_drives >>= 1;
}
}
static void test_GetDiskFreeSpaceW(void)
{
BOOL ret;
DWORD sectors_per_cluster, bytes_per_sector, free_clusters, total_clusters;
WCHAR drive[] = {'?',':','\\',0};
DWORD logical_drives;
static const WCHAR empty_pathW[] = { 0 };
static const WCHAR root_pathW[] = { '\\', 0 };
static const WCHAR unix_style_root_pathW[] = { '/', 0 };
ret = GetDiskFreeSpaceW(NULL, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
{
win_skip("GetDiskFreeSpaceW is not available\n");
return;
}
ok(ret, "GetDiskFreeSpaceW error %d\n", GetLastError());
ret = GetDiskFreeSpaceW(empty_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
"GetDiskFreeSpaceW(\"\"): ret=%d GetLastError=%d\n",
ret, GetLastError());
ret = GetDiskFreeSpaceW(root_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceW(\"\") error %d\n", GetLastError());
ret = GetDiskFreeSpaceW(unix_style_root_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceW error %d\n", GetLastError());
logical_drives = GetLogicalDrives();
ok(logical_drives != 0, "GetLogicalDrives error %d\n", GetLastError());
for (drive[0] = 'A'; drive[0] <= 'Z'; drive[0]++)
{
UINT drivetype = GetDriveTypeW(drive);
/* Skip floppy drives because NT4 pops up a MessageBox if no floppy is present */
if (drivetype != DRIVE_REMOVABLE && drivetype != DRIVE_NO_ROOT_DIR)
{
ret = GetDiskFreeSpaceW(drive, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (!(logical_drives & 1))
ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
"GetDiskFreeSpaceW(%c): ret=%d GetLastError=%d\n",
drive[0], ret, GetLastError());
else if (!ret)
/* GetDiskFreeSpaceW() should succeed, but it can fail with too many
different GetLastError() results to be usable for an ok() */
trace("GetDiskFreeSpaceW(%c) failed with %d\n", drive[0], GetLastError());
}
logical_drives >>= 1;
}
}
ULONG64 GetDriverUseSize(LPCWSTR Latter)
{
DWORD sectorsPerCluster = 0, bytesPerSector = 0, numberOfFreeCluster = 0, numberOfTotalCluster = 0;
GetDiskFreeSpaceW(Latter, §orsPerCluster, &bytesPerSector, &numberOfFreeCluster, &numberOfTotalCluster);
return (ULONG64)sectorsPerCluster*bytesPerSector * (numberOfTotalCluster - numberOfFreeCluster);
}
static void rdwr_nc_read_sector_test(void)
{
DWORD SC, BS, FC, TC;
ASSERT(GetDiskFreeSpaceW(0, &SC, &BS, &FC, &TC));
rdwr_dotest(OPEN_EXISTING, FILE_FLAG_DELETE_ON_CLOSE | FILE_FLAG_NO_BUFFERING,
OptRdwrFileSize, BS, OptRdwrNcCount);
}
static void rdwr_nc_write_sector_test(void)
{
DWORD SC, BS, FC, TC;
ASSERT(GetDiskFreeSpaceW(0, &SC, &BS, &FC, &TC));
rdwr_dotest(CREATE_NEW, 0 | FILE_FLAG_NO_BUFFERING,
OptRdwrFileSize, BS, OptRdwrNcCount);
}
static void rdwr_cc_write_sector_test(void)
{
DWORD SC, BS, FC, TC;
ASSERT(GetDiskFreeSpaceW(0, &SC, &BS, &FC, &TC));
rdwr_dotest(CREATE_NEW, 0,
OptRdwrFileSize, BS, OptRdwrCcCount);
}
int statvfs(const char *path, struct statvfs *buf)
{
BOOL res;
int len;
LPWSTR unicodestr = NULL;
DWORD lpSectorsPerCluster;
DWORD lpBytesPerSector;
DWORD lpNumberOfFreeClusters;
DWORD lpTotalNumberOfClusters;
len = ConvertToUnicode(CP_ACP, 0, path, -1, &unicodestr, 0);
if (len <= 0)
return -1;
res = GetDiskFreeSpaceW(unicodestr, &lpSectorsPerCluster, &lpBytesPerSector, &lpNumberOfFreeClusters, &lpTotalNumberOfClusters);
free(unicodestr);
buf->f_bsize = lpBytesPerSector; /* file system block size */
buf->f_frsize = 0; /* fragment size */
buf->f_blocks = lpTotalNumberOfClusters; /* size of fs in f_frsize units */
buf->f_bfree = lpNumberOfFreeClusters; /* # free blocks */
buf->f_bavail = lpNumberOfFreeClusters; /* # free blocks for unprivileged users */
buf->f_files = 0; /* # inodes */
buf->f_ffree = 0; /* # free inodes */
buf->f_favail = 0; /* # free inodes for unprivileged users */
buf->f_fsid = lpNumberOfFreeClusters & 0xffff; /* file system ID */
buf->f_flag = 0; /* mount flags */
buf->f_namemax = 250; /* maximum filename length */
return res;
}
int win_statvfs(const char *path, backend_statvfsstruct * buf)
{
wchar_t *winpath;
DWORD SectorsPerCluster;
DWORD BytesPerSector;
DWORD NumberOfFreeClusters;
DWORD TotalNumberOfClusters;
ULARGE_INTEGER FreeBytesAvailable;
ULARGE_INTEGER TotalNumberOfBytes;
ULARGE_INTEGER TotalNumberOfFreeBytes;
if (!strcmp("/", path)) {
/* Emulate root */
buf->f_bsize = 1024;
buf->f_blocks = 1024;
buf->f_bfree = 0;
buf->f_bavail = 0;
buf->f_files = 1024;
buf->f_ffree = 0;
return 0;
}
winpath = intpath2winpath(path);
if (!winpath) {
errno = EINVAL;
return -1;
}
winpath[3] = '\0'; /* Cut off after x:\ */
if (!GetDiskFreeSpaceW
(winpath, &SectorsPerCluster, &BytesPerSector, &NumberOfFreeClusters,
&TotalNumberOfClusters)) {
errno = EIO;
return -1;
}
if (!GetDiskFreeSpaceExW
(winpath, &FreeBytesAvailable, &TotalNumberOfBytes,
&TotalNumberOfFreeBytes)) {
errno = EIO;
return -1;
}
buf->f_bsize = BytesPerSector;
buf->f_blocks = TotalNumberOfBytes.QuadPart / BytesPerSector;
buf->f_bfree = TotalNumberOfFreeBytes.QuadPart / BytesPerSector;
buf->f_bavail = FreeBytesAvailable.QuadPart / BytesPerSector;
buf->f_files = buf->f_blocks / SectorsPerCluster;
buf->f_ffree = buf->f_bfree / SectorsPerCluster;
free(winpath);
return 0;
}
//===========================================================================
//ディスクの空き容量を調べる
//===========================================================================
__int64 __fastcall TAttacheCaseFileDecrypt1::GetDiskFreeSpaceNum(String FilePath)
{
int i;
int flag;
__int64 FreeSpace;
String DriveName = ExtractFileDrive(FilePath)+":";
String DirPath = IncludeTrailingPathDelimiter(ExtractFileDir(FilePath));
OSVERSIONINFO ovi; // バージョン情報を格納する構造体
ovi.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
// バージョン情報取得
GetVersionEx( (LPOSVERSIONINFO)&ovi );
// Windows95 OSR2以前
if( ( ovi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
&& ( int( ovi.dwBuildNumber & 0xffff ) <= 1000 ) ){
DWORD SCluster,BSector,FCluster,TCluster;
if ( GetDiskFreeSpaceW(String(DriveName).c_str(), &SCluster, &BSector, &FCluster, &TCluster) > 0){
FreeSpace = SCluster*BSector*FCluster;
}
else{
//ネットワークサーバ上は取得できずエラーとなる
FreeSpace = -1;
}
}
// OSR2以降～
else{
ULARGE_INTEGER pqwFreeCaller;
ULARGE_INTEGER pqwTot;
ULARGE_INTEGER pqwFree;
if(::GetDiskFreeSpaceExW(String(DirPath).c_str(), &pqwFreeCaller, &pqwTot, &pqwFree)){
//64bit Integerで返す
FreeSpace = pqwFreeCaller.QuadPart;
}
else{
FreeSpace = -1;
}
}
return(FreeSpace);
}//end GetDiskFreeSpaceNum;
qulonglong Utils::filesystemSize(QString path, enum Utils::Size type)
{
qlonglong size = 0;
#if defined(Q_OS_LINUX) || defined(Q_OS_MACX)
// the usage of statfs() is deprecated by the LSB so use statvfs().
struct statvfs fs;
int ret;
ret = statvfs(qPrintable(path), &fs);
if(ret == 0) {
if(type == FilesystemFree) {
size = (qulonglong)fs.f_frsize * (qulonglong)fs.f_bavail;
}
if(type == FilesystemTotal) {
size = (qulonglong)fs.f_frsize * (qulonglong)fs.f_blocks;
}
if(type == FilesystemClusterSize) {
size = (qulonglong)fs.f_frsize;
}
}
#endif
#if defined(Q_OS_WIN32)
BOOL ret;
ULARGE_INTEGER freeAvailBytes;
ULARGE_INTEGER totalNumberBytes;
ret = GetDiskFreeSpaceExW((LPCTSTR)path.utf16(), &freeAvailBytes,
&totalNumberBytes, NULL);
if(ret) {
if(type == FilesystemFree) {
size = freeAvailBytes.QuadPart;
}
if(type == FilesystemTotal) {
size = totalNumberBytes.QuadPart;
}
if(type == FilesystemClusterSize) {
DWORD sectorsPerCluster;
DWORD bytesPerSector;
DWORD freeClusters;
DWORD totalClusters;
ret = GetDiskFreeSpaceW((LPCTSTR)path.utf16(), §orsPerCluster,
&bytesPerSector, &freeClusters, &totalClusters);
if(ret) {
size = bytesPerSector * sectorsPerCluster;
}
}
}
#endif
return size;
}
unsigned long long disk_size(std::string drive) {
DWORD sectorsPerCluster, bytesPerSector, totalClusters, freeClusters;
tstring tstr_drive = widen(drive);
tstring tstr_colonslash = widen(":\\");
tstring tstr_empty = widen("");
if (tstr_drive.length() == 1) tstr_drive += tstr_colonslash;
if (!GetDiskFreeSpaceW((tstr_drive == tstr_empty) ? NULL : tstr_drive.c_str(), §orsPerCluster, &bytesPerSector,
&freeClusters, &totalClusters))
return 0;
return (unsigned long long)(totalClusters * sectorsPerCluster) * (unsigned long long)bytesPerSector;
}
sint64 VDGetDiskFreeSpace(const wchar_t *path) {
typedef BOOL (WINAPI *tpGetDiskFreeSpaceExA)(LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailable, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes);
typedef BOOL (WINAPI *tpGetDiskFreeSpaceExW)(LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailable, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes);
static bool sbChecked = false;
static tpGetDiskFreeSpaceExA spGetDiskFreeSpaceExA;
static tpGetDiskFreeSpaceExW spGetDiskFreeSpaceExW;
if (!sbChecked) {
HMODULE hmodKernel = GetModuleHandle("kernel32.dll");
spGetDiskFreeSpaceExA = (tpGetDiskFreeSpaceExA)GetProcAddress(hmodKernel, "GetDiskFreeSpaceExA");
spGetDiskFreeSpaceExW = (tpGetDiskFreeSpaceExW)GetProcAddress(hmodKernel, "GetDiskFreeSpaceExW");
sbChecked = true;
}
if (spGetDiskFreeSpaceExA) {
BOOL success;
uint64 freeClient, totalBytes, totalFreeBytes;
VDStringW directoryName(path);
if (!directoryName.empty()) {
wchar_t c = directoryName[directoryName.length()-1];
if (c != L'/' && c != L'\\')
directoryName += L'\\';
}
if ((LONG)GetVersion() < 0)
success = spGetDiskFreeSpaceExA(VDTextWToA(directoryName).c_str(), (PULARGE_INTEGER)&freeClient, (PULARGE_INTEGER)&totalBytes, (PULARGE_INTEGER)&totalFreeBytes);
else
success = spGetDiskFreeSpaceExW(directoryName.c_str(), (PULARGE_INTEGER)&freeClient, (PULARGE_INTEGER)&totalBytes, (PULARGE_INTEGER)&totalFreeBytes);
return success ? (sint64)freeClient : -1;
} else {
DWORD sectorsPerCluster, bytesPerSector, freeClusters, totalClusters;
BOOL success;
VDStringW rootPath(VDFileGetRootPath(path));
if ((LONG)GetVersion() < 0)
success = GetDiskFreeSpaceA(rootPath.empty() ? NULL : VDTextWToA(rootPath).c_str(), §orsPerCluster, &bytesPerSector, &freeClusters, &totalClusters);
else
success = GetDiskFreeSpaceW(rootPath.empty() ? NULL : rootPath.c_str(), §orsPerCluster, &bytesPerSector, &freeClusters, &totalClusters);
return success ? (sint64)((uint64)sectorsPerCluster * bytesPerSector * freeClusters) : -1;
}
}
/***********************************************************************
* SetupCreateDiskSpaceListW (SETUPAPI.@)
*/
HDSKSPC WINAPI SetupCreateDiskSpaceListW(PVOID Reserved1, DWORD Reserved2, UINT Flags)
{
WCHAR drives[255];
DWORD rc;
WCHAR *ptr;
LPDISKSPACELIST list=NULL;
TRACE("(%p, %u, 0x%08x)\n", Reserved1, Reserved2, Flags);
if (Reserved1 || Reserved2 || Flags & ~SPDSL_IGNORE_DISK)
{
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
rc = GetLogicalDriveStringsW(255,drives);
if (rc == 0)
return NULL;
list = HeapAlloc(GetProcessHeap(),0,sizeof(DISKSPACELIST));
list->dwDriveCount = 0;
ptr = drives;
while (*ptr)
{
DWORD type = GetDriveTypeW(ptr);
if (type == DRIVE_FIXED)
{
DWORD clusters;
DWORD sectors;
DWORD bytes;
DWORD total;
lstrcpyW(list->Drives[list->dwDriveCount].lpzName,ptr);
GetDiskFreeSpaceW(ptr,§ors,&bytes,&clusters,&total);
list->Drives[list->dwDriveCount].dwFreeSpace = clusters * sectors *
bytes;
list->Drives[list->dwDriveCount].dwWantedSpace = 0;
list->dwDriveCount++;
}
ptr += lstrlenW(ptr) + 1;
}
return list;
}
/***********************************************************************
* SetupCreateDiskSpaceListW (SETUPAPI.@)
*/
HDSKSPC WINAPI SetupCreateDiskSpaceListW(PVOID Reserved1, DWORD Reserved2, UINT Flags)
{
WCHAR drives[255];
DWORD rc;
WCHAR *ptr;
LPDISKSPACELIST list=NULL;
rc = GetLogicalDriveStringsW(255,drives);
if (rc == 0)
return NULL;
list = HeapAlloc(GetProcessHeap(),0,sizeof(DISKSPACELIST));
list->dwDriveCount = 0;
ptr = drives;
while (*ptr)
{
DWORD type = GetDriveTypeW(ptr);
if (type == DRIVE_FIXED)
{
DWORD clusters;
DWORD sectors;
DWORD bytes;
DWORD total;
lstrcpyW(list->Drives[list->dwDriveCount].lpzName,ptr);
GetDiskFreeSpaceW(ptr,§ors,&bytes,&clusters,&total);
list->Drives[list->dwDriveCount].dwFreeSpace = clusters * sectors *
bytes;
list->Drives[list->dwDriveCount].dwWantedSpace = 0;
list->dwDriveCount++;
}
ptr += lstrlenW(ptr) + 1;
}
return list;
}
/*********************************************************************
* _getdiskfree (MSVCRT.@)
*
* Get information about the free space on a drive.
*
* PARAMS
* disk [I] Drive number to get information about (1 = 'A', 2 = 'B', ...)
* info [O] Destination for the resulting information.
*
* RETURNS
* Success: 0. info is updated with the free space information.
* Failure: An error code from GetLastError().
*
* NOTES
* See GetLastError().
*/
unsigned int CDECL MSVCRT__getdiskfree(unsigned int disk, struct MSVCRT__diskfree_t * d)
{
WCHAR drivespec[] = {'@', ':', '\\', 0};
DWORD ret[4];
unsigned int err;
if (disk > 26)
return ERROR_INVALID_PARAMETER; /* MSVCRT doesn't set errno here */
drivespec[0] += disk; /* make a drive letter */
if (GetDiskFreeSpaceW(disk==0?NULL:drivespec,ret,ret+1,ret+2,ret+3))
{
d->sectors_per_cluster = ret[0];
d->bytes_per_sector = ret[1];
d->avail_clusters = ret[2];
d->total_clusters = ret[3];
return 0;
}
err = GetLastError();
msvcrt_set_errno(err);
return err;
}
RTR3DECL(int) RTFsQuerySizes(const char *pszFsPath, RTFOFF *pcbTotal, RTFOFF *pcbFree,
uint32_t *pcbBlock, uint32_t *pcbSector)
{
/*
* Validate & get valid root path.
*/
AssertMsgReturn(VALID_PTR(pszFsPath) && *pszFsPath, ("%p", pszFsPath), VERR_INVALID_PARAMETER);
PRTUTF16 pwszFsRoot;
int rc = rtFsGetRoot(pszFsPath, &pwszFsRoot);
if (RT_FAILURE(rc))
return rc;
/*
* Free and total.
*/
if (pcbTotal || pcbFree)
{
ULARGE_INTEGER cbTotal;
ULARGE_INTEGER cbFree;
if (GetDiskFreeSpaceExW(pwszFsRoot, &cbFree, &cbTotal, NULL))
{
if (pcbTotal)
*pcbTotal = cbTotal.QuadPart;
if (pcbFree)
*pcbFree = cbFree.QuadPart;
}
else
{
DWORD Err = GetLastError();
rc = RTErrConvertFromWin32(Err);
Log(("RTFsQuerySizes(%s,): GetDiskFreeSpaceEx failed with lasterr %d (%Rrc)\n",
pszFsPath, Err, rc));
}
}
/*
* Block and sector size.
*/
if ( RT_SUCCESS(rc)
&& (pcbBlock || pcbSector))
{
DWORD dwDummy1, dwDummy2;
DWORD cbSector;
DWORD cSectorsPerCluster;
if (GetDiskFreeSpaceW(pwszFsRoot, &cSectorsPerCluster, &cbSector, &dwDummy1, &dwDummy2))
{
if (pcbBlock)
*pcbBlock = cbSector * cSectorsPerCluster;
if (pcbSector)
*pcbSector = cbSector;
}
else
{
DWORD Err = GetLastError();
rc = RTErrConvertFromWin32(Err);
Log(("RTFsQuerySizes(%s,): GetDiskFreeSpace failed with lasterr %d (%Rrc)\n",
pszFsPath, Err, rc));
}
}
rtFsFreeRoot(pwszFsRoot);
return rc;
}
FSNTFSWIN::FSNTFSWIN(const std::string &pDev, IFSImageFactory::EReadaheadMode read_ahead, bool background_priority, IFsNextBlockCallback* next_block_callback)
: Filesystem(pDev, read_ahead, next_block_callback), bitmap(NULL)
{
HANDLE hDev=CreateFileW( Server->ConvertToWchar(pDev).c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_NO_BUFFERING, NULL );
if(hDev==INVALID_HANDLE_VALUE)
{
Server->Log("Error opening device -2", LL_ERROR);
has_error=true;
return;
}
DWORD sectors_per_cluster;
DWORD bytes_per_sector;
DWORD NumberOfFreeClusters;
DWORD TotalNumberOfClusters;
BOOL b=GetDiskFreeSpaceW((Server->ConvertToWchar(pDev)+L"\\").c_str(), §ors_per_cluster, &bytes_per_sector, &NumberOfFreeClusters, &TotalNumberOfClusters);
if(!b)
{
Server->Log("Error in GetDiskFreeSpaceW", LL_ERROR);
has_error=true;
CloseHandle(hDev);
return;
}
DWORD r_bytes;
NTFS_VOLUME_DATA_BUFFER vdb;
b=DeviceIoControl(hDev, FSCTL_GET_NTFS_VOLUME_DATA, NULL, 0, &vdb, sizeof(NTFS_VOLUME_DATA_BUFFER), &r_bytes, NULL);
if(!b)
{
Server->Log("Error in DeviceIoControl(FSCTL_GET_NTFS_VOLUME_DATA)", LL_ERROR);
has_error=true;
CloseHandle(hDev);
return;
}
sectorsize=bytes_per_sector;
clustersize=sectorsize*sectors_per_cluster;
drivesize=vdb.NumberSectors.QuadPart*sectorsize;
uint64 numberOfClusters=drivesize/clustersize;
STARTING_LCN_INPUT_BUFFER start;
LARGE_INTEGER li;
li.QuadPart=0;
start.StartingLcn=li;
size_t new_size=(size_t)(numberOfClusters/8);
if(numberOfClusters%8!=0)
++new_size;
size_t n_clusters=new_size;
new_size+=sizeof(VOLUME_BITMAP_BUFFER);
VOLUME_BITMAP_BUFFER *vbb=(VOLUME_BITMAP_BUFFER*)(new char[new_size]);
b=DeviceIoControl(hDev, FSCTL_GET_VOLUME_BITMAP, &start, sizeof(STARTING_LCN_INPUT_BUFFER), vbb, (DWORD)new_size, &r_bytes, NULL);
if(!b)
{
Server->Log("DeviceIoControl(FSCTL_GET_VOLUME_BITMAP) failed", LL_ERROR);
has_error=true;
CloseHandle(hDev);
return;
}
Server->Log("TotalNumberOfClusters="+convert((size_t)TotalNumberOfClusters)+" numberOfClusters="+convert(numberOfClusters)+" n_clusters="+convert(n_clusters)+" StartingLcn="+convert(vbb->StartingLcn.QuadPart)+" BitmapSize="+convert(vbb->BitmapSize.QuadPart)+" r_bytes="+convert((size_t)r_bytes), LL_DEBUG);
bitmap=new unsigned char[(unsigned int)(n_clusters)];
memset(bitmap, 0xFF, n_clusters);
memcpy(bitmap+(unsigned int)(vbb->StartingLcn.QuadPart/8), vbb->Buffer, (size_t)(vbb->BitmapSize.QuadPart/8));
delete []vbb;
CloseHandle(hDev);
initReadahead(read_ahead, background_priority);
}
static int statfs (const unsigned char *path, struct statfs *buf)
{
HINSTANCE h;
FARPROC f;
int retval = 0;
WCHAR tmp [MAX_PATH], resolved_path [MAX_PATH];
WCHAR * wpath = (WCHAR *)utf8_to_utf16(path);
realpath(wpath, resolved_path);
free(wpath);
if (!resolved_path)
retval = - 1;
else
{
/* check whether GetDiskFreeSpaceExA is supported */
h = LoadLibraryA ("kernel32.dll");
if (h)
f = GetProcAddress (h, "GetDiskFreeSpaceExW");
else
f = NULL;
if (f)
{
ULARGE_INTEGER bytes_free, bytes_total, bytes_free2;
if (!f (resolved_path, &bytes_free2, &bytes_total, &bytes_free))
{
errno = ENOENT;
retval = - 1;
}
else
{
buf -> f_bsize = FAKED_BLOCK_SIZE;
buf -> f_bfree = (bytes_free.QuadPart) / FAKED_BLOCK_SIZE;
buf -> f_files = buf -> f_blocks = (bytes_total.QuadPart) / FAKED_BLOCK_SIZE;
buf -> f_ffree = buf -> f_bavail = (bytes_free2.QuadPart) / FAKED_BLOCK_SIZE;
}
}
else
{
DWORD sectors_per_cluster, bytes_per_sector;
if (h) FreeLibrary (h);
if (!GetDiskFreeSpaceW (resolved_path, §ors_per_cluster,
&bytes_per_sector, &buf -> f_bavail, &buf -> f_blocks))
{
errno = ENOENT;
retval = - 1;
}
else
{
buf -> f_bsize = sectors_per_cluster * bytes_per_sector;
buf -> f_files = buf -> f_blocks;
buf -> f_ffree = buf -> f_bavail;
buf -> f_bfree = buf -> f_bavail;
}
}
if (h) FreeLibrary (h);
}
/* get the FS volume information */
if (wcsspn (L":", resolved_path) > 0) resolved_path [3] = '\0'; /* we want only the root */
if (GetVolumeInformationW (resolved_path, NULL, 0, &buf -> f_fsid, &buf -> f_namelen, NULL, tmp, MAX_PATH))
/* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/fs/getvolumeinformation.asp */
{
if (_wcsicmp (L"NTFS", tmp) == 0)
{
buf -> f_type = NTFS_SUPER_MAGIC;
}
else
{
buf -> f_type = MSDOS_SUPER_MAGIC;
}
}
else
{
errno = ENOENT;
retval = - 1;
}
return retval;
}
int __cdecl main(int argc, char *argv[])
{
BOOL testPass = TRUE;
BOOL bRc = TRUE;
DWORD lastErr=-50;
DWORD dwSectorsPerCluster_02; /* sectors per cluster */
DWORD dwBytesPerSector_02; /* bytes per sector */
DWORD dwNumberOfFreeClusters; /* free clusters */
DWORD dwTotalNumberOfClusters; /* total clusters */
UINT uiError = 0;
char szReturnedName[256];
const UINT uUnique = 0;
const char* sDot = {"tmpr"};
const char* sPrefix = {"cfr"};
WCHAR wzReturnedName[256];
const WCHAR wDot[] = {'t','m','p','r','\0'};
const WCHAR wPrefix[] = {'c','f','r','\0'};
const WCHAR wBadFilePath[] =
{'w','b','a','d','/','b','a',
'd','.','t','m','p','\0'};
const WCHAR wBadFileName[] =
{'w','B','a','d','.','t','m','p','\0'};
if (0 != PAL_Initialize(argc,argv))
{
return FAIL;
}
/* test .................. GetDiskFreeSpaceW .................. */
/* test with invalid file name */
bRc = GetDiskFreeSpaceW(wBadFileName,
&dwSectorsPerCluster_02,
&dwBytesPerSector_02,
&dwNumberOfFreeClusters,
&dwTotalNumberOfClusters);
if (bRc != TRUE)
{
lastErr=GetLastError();
if(lastErr != ERROR_FILE_NOT_FOUND)
{
Trace("GetDiskFreeSpaceW: calling GetLastError() returned [%u] "
"while it should return [%u] for a bad File Name\n",
lastErr,ERROR_FILE_NOT_FOUND);
testPass = FALSE;
}
}
else
{
Trace("GetDiskFreeSpaceW: GetDiskFreeSpaceW succeeded when given "
"a bad fileName\n");
testPass = FALSE;
}
/* test with invalid path name */
bRc = GetDiskFreeSpaceW(wBadFilePath,
&dwSectorsPerCluster_02,
&dwBytesPerSector_02,
&dwNumberOfFreeClusters,
&dwTotalNumberOfClusters);
if (bRc != TRUE)
{
lastErr=GetLastError();
if(lastErr != ERROR_PATH_NOT_FOUND)
{
Trace("GetDiskFreeSpaceW: calling GetLastError() returned [%u] "
"while it should return [%u] for a bad File Name\n",
lastErr,ERROR_PATH_NOT_FOUND);
testPass = FALSE;
}
}
else
{
Trace("GetDiskFreeSpaceW: GetDiskFreeSpaceW succeeded when given "
"a bad fileName\n");
testPass = FALSE;
}
/* test .................. GetTempFileNameA .................. */
/* test with invalid path name */
uiError = GetTempFileNameA(sDot, sPrefix, uUnique, szReturnedName);
if (uiError == 0)
{
lastErr=GetLastError();
if(lastErr != ERROR_DIRECTORY)
{
Trace("GetTempFileNameA: calling GetLastError() returned [%u] "
"while it should return [%u] for invalid path name\n",
lastErr,ERROR_DIRECTORY);
testPass = FALSE;
}
}
else
{
Trace("GetTempFileNameA: GetTempFileNameA succeeded when given "
"invalid path name\n");
testPass = FALSE;
}
/* test .................. GetTempFileNameW .................. */
/* test with invalid path name */
uiError = GetTempFileNameW(wDot, wPrefix, uUnique, wzReturnedName);
if (uiError == 0)
{
lastErr=GetLastError();
if(lastErr != ERROR_DIRECTORY)
{
Trace("GetTempFileNameW: calling GetLastError() returned [%u] "
"while it should return [%u] for an invalid path name\n",
lastErr,ERROR_DIRECTORY);
testPass = FALSE;
}
}
else
{
Trace("GetTempFileNameW: GetTempFileNameW succeeded when given"
" an invalid path name\n");
testPass = FALSE;
}
if(! testPass)
{
Fail("");
}
PAL_Terminate();
return PASS;
}
int _tmain(int argc, _TCHAR* argv[])
{
// argv[1] = L"d:\\myfile.txt";
// argc = 2;
if (argc < 2)
{
printf("usage example: c:\\myfile.txt \n");
return -1;
}
HANDLE hDevHandle=INVALID_HANDLE_VALUE;
INT res=-1;
PRETRIEVAL_POINTERS_BUFFER prpb=NULL;
LARGE_INTEGER file_size;
DWORD SectorsPerCluster;
DWORD BytesPerSector;
DWORD NumberOfFreeClusters;
DWORD TotalNumberOfClusters;
WCHAR fs_path[4]; //путь в виде "C:\\"
memset(fs_path, 0, 4*sizeof(WCHAR) );
memcpy( fs_path, argv[1], 3*sizeof(WCHAR) );
if (!GetDiskFreeSpaceW(
fs_path,
&SectorsPerCluster,
&BytesPerSector,
&NumberOfFreeClusters,
&TotalNumberOfClusters
)
)
{
printf("GetDiskFreeSpaceW error\n");
return -1;
}
hDevHandle = CreateFileW(
argv[1],//fs_path,
GENERIC_READ /*| GENERIC_WRITE*/,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING,
NULL
);
if (hDevHandle==INVALID_HANDLE_VALUE)
{
printf("CreateFileW error\n");
return -1;
}
if (GetFileSizeEx(hDevHandle,&file_size)<0)
{
printf("GetFileSizeEx error\n");
return -1;
}
DWORD file_cl_cnt;
DWORD cluster_size=SectorsPerCluster*BytesPerSector;
if (file_size.QuadPart< cluster_size || file_size.QuadPart%cluster_size>0)
{
file_cl_cnt=(DWORD)(file_size.QuadPart/cluster_size+1);
}
else
{
file_cl_cnt=(DWORD)(file_size.QuadPart/cluster_size);
}
STARTING_VCN_INPUT_BUFFER start_vcn;
start_vcn.StartingVcn.QuadPart=file_cl_cnt-1;
prpb=(PRETRIEVAL_POINTERS_BUFFER )new char[sizeof(RETRIEVAL_POINTERS_BUFFER )+sizeof(LARGE_INTEGER)*2*10];
DWORD nRead;
if (!DeviceIoControl(hDevHandle,
FSCTL_GET_RETRIEVAL_POINTERS,
&start_vcn,
sizeof(STARTING_VCN_INPUT_BUFFER),
prpb,
sizeof(RETRIEVAL_POINTERS_BUFFER )+sizeof(LARGE_INTEGER)*2*10,
&nRead,
NULL))
{
//очень маленький файл находиться в MFT
DWORD err = GetLastError();
if (err == ERROR_HANDLE_EOF )
printf("DeviceIoControl error: file is too small\n");
else
printf("DeviceIoControl error: GetLastError = %d \n", err);
}
else
{
printf("DeviceIoControl success\n");
}
CloseHandle(hDevHandle);
hDevHandle=NULL;
delete [] prpb;
return 0;
}
