int LbDriveFreeSpace(const unsigned int drive, struct TbDriveInfo *drvinfo)
{
int result;
#if defined(WIN32)||defined(DOS)||defined(GO32)
struct _diskfree_t diskspace;
int reterror = _getdiskfree(drive, &diskspace);
if ( reterror )
{
result = -1;
} else
{
drvinfo->TotalClusters = diskspace.total_clusters;
drvinfo->FreeClusters = diskspace.avail_clusters;
drvinfo->SectorsPerCluster = diskspace.sectors_per_cluster;
drvinfo->BytesPerSector = diskspace.bytes_per_sector;
result = 1;
}
#else
//On non-win32 systems - return anything big enough
drvinfo->TotalClusters = 65535;
drvinfo->FreeClusters = 65535;
drvinfo->SectorsPerCluster = 512;
drvinfo->BytesPerSector = 512;
result = 1;
#endif
return result;
}
bool CheckStorage(const uint64 diskSpaceNeeded)
{
//Creamos variables temporales
const int32 drive = _getdrive(); //Indice del disco actual
_diskfree_t diskfree; //Estructura de información de espacio libre
//Obtenemos la información de espacio libre en el disco actual
if( _getdiskfree(drive, &diskfree) != 0 )
{//Si falló al obtener el espacio libre del disco
//Mandamos un error
GEE_ERROR(TEXT("CheckStorage() - Fallo al obtener el tamaño de espacio libre del disco duro"));
}
//Calculamos el número de clusters requeridos de acuerdo a la cantidad de espacio pedido
const uint64 neededClusters = diskSpaceNeeded / (diskfree.sectors_per_cluster * diskfree.bytes_per_sector);
//Revisamos si el espacio libre es suficiente de acuerdo al espacio necesitado
if(diskfree.avail_clusters < neededClusters)
{//Si no hay suficiente espacio libre en el disco duro
//Informamos el error
GEE_ERROR(TEXT("CheckStorage: No hay suficiente espacio libre en el disco duro"));
return false;
}
return true;
}
/*----------------------------------------------------------------------*
rtp_wfile_get_free
*----------------------------------------------------------------------*/
int rtp_wfile_get_free (unsigned short * name, unsigned long *total, unsigned long *free,
unsigned long *sectors_per_unit, unsigned short *bytes_per_sector)
{
#if (_WIN32_WINNT) >= 0x0400
struct _diskfree_t dtable_entry = {0};
int tmpDrive;
int result;
#ifdef RTP_DEBUG
SetLastError (0);
#endif
name = _rtp_unicode_name_to_winname (name);
tmpDrive = towlower((int) name[0]);
tmpDrive = (tmpDrive - 'a') + 1;
result = _getdiskfree (tmpDrive, &dtable_entry);
if (result != 0)
{
#ifdef RTP_DEBUG
RTP_DEBUG_OUTPUT_ERRNO("rtp_wfile_get_free:");
#endif
return (-1);
}
*total = (unsigned long) dtable_entry.total_clusters;
*free = (unsigned long) dtable_entry.avail_clusters;
*sectors_per_unit = (unsigned long) dtable_entry.sectors_per_cluster;
*bytes_per_sector = (unsigned short) dtable_entry.bytes_per_sector;
return (0);
#endif
return (-1);
}
/**
* The getTotalSize function checks the total space in storage.
*/
long pcsl_file_gettotalsize(const pcsl_string * path)
{
struct _diskfree_t df;
struct _stat buf;
jlong size;
int res;
const jchar * pszOsFilename = pcsl_string_get_utf16_data(path);
if (NULL == pszOsFilename) {
return -1;
}
res = _wstat(pszOsFilename, &buf);
pcsl_string_release_utf16_data(pszOsFilename, path);
if (0 != res) {
return -1;
}
if (0 != _getdiskfree(buf.st_dev + 1, &df)) {
return -1;
}
size = (jlong)(df.total_clusters) * df.sectors_per_cluster * df.bytes_per_sector;
return (size > 0x7FFFFFFFL) ? 0x7FFFFFFFL : (long)size;
}
void CNFS2Prog::ProcedureSTATFS(void)
{
char *path;
int nDrive;
struct _diskfree_t data;
PrintLog("STATFS");
path = GetPath();
if (!CheckFile(path))
return;
if (path[0] >= 'a' && path[0] <= 'z')
nDrive = path[0] - 'a' + 1;
else if (path[0] >= 'A' && path[0] <= 'Z')
nDrive = path[0] - 'A' + 1;
else
{
m_pOutStream->Write(NFSERR_NOENT);
return;
}
_getdiskfree(nDrive, &data);
m_pOutStream->Write(NFS_OK);
m_pOutStream->Write(data.sectors_per_cluster * data.bytes_per_sector); //transfer size
m_pOutStream->Write(data.sectors_per_cluster * data.bytes_per_sector); //block size
m_pOutStream->Write(data.total_clusters); //total blocks
m_pOutStream->Write(data.avail_clusters); //free blocks
m_pOutStream->Write(data.avail_clusters); //available blocks
}
int KHttpFile::CheckDiskSpace()
{
int nRetCode = false;
int nResult = false;
TCHAR cDisk = m_strFile[0];
unsigned __int64 nAvailableSpace = 0;
struct _diskfree_t DiskFree;
//磁盘空间是否足够
if (cDisk >= _T('a') && cDisk <= _T('z'))
cDisk += 'A' - 'a';
nRetCode = _getdiskfree(cDisk - _T('A') + 1, &DiskFree);
KGLOG_PROCESS_ERROR(!nRetCode);
nAvailableSpace = DiskFree.avail_clusters;
nAvailableSpace *= DiskFree.sectors_per_cluster;
nAvailableSpace *= DiskFree.bytes_per_sector;
KGLOG_PROCESS_ERROR(nAvailableSpace > m_nFileSize - m_nDownloadedSize);
nResult = true;
Exit0:
if (!nResult)
{
m_nErrorCode = dec_err_noenoughdiskspace;
}
return nResult;
}
static BOOL CheckFreeSpace(char *path)
{
#ifdef __WATCOMC__
struct diskfree_t space;
#else
struct dfree space;
getdfree(path[0] - 'A' + 1, &space);
#endif
#ifdef __WATCOMC__
if (!_getdiskfree(path[0] - 'A' + 1, &space))
#else
if (space.df_sclus != 0xFFFF)
#endif
{
#ifdef __WATCOMC__
unsigned long bytes = ((unsigned long) space.avail_clusters *
(unsigned long) space.bytes_per_sector *
(unsigned long) space.sectors_per_cluster);
#else
unsigned long bytes = ((unsigned long) space.df_avail *
(unsigned long) space.df_bsec *
(unsigned long) space.df_sclus);
#endif
LIST_LOOP loop;
if (idTimeStamps && idTimeStamps != lpIDs->idNull)
{
unsigned long size = 0L;
ATOMID idFile;
kpc_init_loop(idTimeStamps, &loop);
while (idFile = KppNextListElement(&loop)) {
struct stat st;
KppNextListElement(&loop);
KppGetAtomName(idFile, &return_buffer, RET_BUFFER_LEN);
if (!stat(return_buffer, &st))
size += st.st_size;
}
if (bytes < size)
{
return_buffer[0] = path[0];
return_buffer[1] = '\0';
return PostAlertYesNo(NULL, IDE_DISKSPACE,
return_buffer, ES, ES) == IDYES;
}
}
}
return TRUE;
}
/**
* Determines the total size in bytes of the file system the file
* or directory resides on
* @param pathName file name in UNICODE of any file within the file system
* @param pathNameLen length of path name
* @param result returned value: on success, total size of storage space (bytes)
* @return <tt>JAVACALL_OK</tt> if operation completed successfully,
* <tt>JAVACALL_FAIL</tt> otherwise.
*/
javacall_result javacall_fileconnection_get_total_size(const javacall_utf16* pathName,
int pathNameLen,
javacall_int64* /* OUT */ result) {
struct _diskfree_t df;
if(0 != _getdiskfree(pathName[0] - (pathName[0] > 'Z' ? 'a' : 'A') + 1, &df)) {
javacall_print("Error: javacall_fileconnection_get_total_size(), cannot get total space\n");
return JAVACALL_FAIL;
}
*result = (javacall_int64)(df.total_clusters) * df.sectors_per_cluster * df.bytes_per_sector;
return JAVACALL_OK;
}
void CheckHardDisk(const DWORDLONG space_needed)
{
//check for enough free space on currect disk
const int drive = _getdrive();
struct _diskfree_t diskfree;
_getdiskfree(drive, &diskfree);
unsigned __int64 const need_clusters = space_needed / (diskfree.sectors_per_cluster*diskfree.bytes_per_sector);
if(diskfree.avail_clusters < need_clusters)
{
//if you get here you do not have enough disk space
throw KhaosError(ERR_INIT_NOT_ENOUGH_DISK_SPACE);
}
}
bool chk_hdd(unsigned __int64 spaceNeeded)
{
// get the system drive
const int drive = _getdrive();
struct _diskfree_t diskfree;
// get the amount of free space
_getdiskfree(drive, &diskfree);
// calculate how many clusters are needed
const unsigned __int64 neededClusters = spaceNeeded / (diskfree.sectors_per_cluster * diskfree.bytes_per_sector);
// check if there are enough free clusters
if(diskfree.avail_clusters < neededClusters)
return false;
return true;
}
double FILE_DiskSpace( char DriveLetter )
{
struct _diskfree_t driveinfo;
int drive;
unsigned int rc=0;
double space=-1.0;
STRING DriveString;
// Make sure FILE API is started...
if( !FILE_API_check() )
{
return(space);
}
if( DriveLetter == 0x00 )
{
drive = 0;
memset(DriveString,0,STRLEN);
}
else
{
drive = 1 + (unsigned int)toupper(DriveLetter) - 'A';
strncpy(DriveString,STR_stringf("%c:",DriveLetter),STRLEN);
}
if( (drive < 0) || (drive > 26) )
{
FILE_errorf("FILE_DiskSpace(%c:) Invalid drive specified (drive=%d).\n",DriveLetter,drive);
return(space);
}
rc = _getdiskfree(drive,&driveinfo);
if( rc == 0 )
{
space = (double)driveinfo.avail_clusters * (double)driveinfo.sectors_per_cluster * (double)driveinfo.bytes_per_sector;
}
else
{
FILE_errorf("FILE_DiskSpace(%s) Failed (%s[%d]).\n",DriveString,strerror(errno),errno);
}
return(space);
}
bool PlatformManager::check_for_free_space(const u64 space_required) const
{
bool result = false;
const s32 drive = _getdrive();
_diskfree_t disk_free = {};
_getdiskfree(drive, &disk_free);
const u64 clusters_required = space_required / (disk_free.sectors_per_cluster * disk_free.bytes_per_sector);
XE_PRINT("Disk space: %lu MBs", disk_free.avail_clusters * disk_free.sectors_per_cluster * disk_free.bytes_per_sector / 1024 / 1024);
result = disk_free.avail_clusters > clusters_required;
if (!result)
{
XE_ERROR(false, "You don't have enough free storage. Please, free up some space.");
}
return result;
}
/*----------------------------------------------------------------------*
rtp_wfile_get_free
*----------------------------------------------------------------------*/
int rtp_wfile_get_free (unsigned short * name, unsigned long *total, unsigned long *free,
unsigned long *sectors_per_unit, unsigned short *bytes_per_sector)
{
#if (_WIN32_WINNT) >= 0x0400
struct _diskfree_t dtable_entry = {0};
int tmpDrive;
int result;
#ifdef RTP_DEBUG
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
SetLastError (0);
#endif
name = _rtp_unicode_name_to_winname (name);
tmpDrive = towlower((int) name[0]);
tmpDrive = (tmpDrive - 'a') + 1;
result = _getdiskfree (tmpDrive, &dtable_entry);
if (result != 0)
{
#ifdef RTP_DEBUG
result = GetLastError();
RTP_DEBUG_OUTPUT_STR("rtp_wfile_get_free: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*total = (unsigned long) dtable_entry.total_clusters;
*free = (unsigned long) dtable_entry.avail_clusters;
*sectors_per_unit = (unsigned long) dtable_entry.sectors_per_cluster;
*bytes_per_sector = (unsigned short) dtable_entry.bytes_per_sector;
return (0);
#endif
return (-1);
}
// /////////////////////////////////////////////////////////////////
//
// /////////////////////////////////////////////////////////////////
bool SystemCheck::CheckHardDiskSpace(const I64 minFreeSpace)
{
bool result = false; // Result of method.
#ifdef _WINDOWS
I32 const drive = _getdrive(); // HD drive ID/number.
struct _diskfree_t diskfree; // Disk check struct.
memset((void *)&diskfree, 0, sizeof(diskfree));
_getdiskfree(drive, &diskfree);
unsigned __int64 const neededClusters =
minFreeSpace /(diskfree.sectors_per_cluster*diskfree.bytes_per_sector);
if(diskfree.avail_clusters < neededClusters)
{
result = false;
}
#endif
return (result);
}
void FiosGetDrives(FileList &file_list)
{
uint disk, disk2, save, total;
#ifndef __INNOTEK_LIBC__
_dos_getdrive(&save); // save original drive
#else
save = _getdrive(); // save original drive
char wd[MAX_PATH];
getcwd(wd, MAX_PATH);
total = 'z';
#endif
/* get an available drive letter */
#ifndef __INNOTEK_LIBC__
for (disk = 1;; disk++) {
_dos_setdrive(disk, &total);
#else
for (disk = 'A';; disk++) {
_chdrive(disk);
#endif
if (disk >= total) break;
#ifndef __INNOTEK_LIBC__
_dos_getdrive(&disk2);
#else
disk2 = _getdrive();
#endif
if (disk == disk2) {
FiosItem *fios = file_list.Append();
fios->type = FIOS_TYPE_DRIVE;
fios->mtime = 0;
#ifndef __INNOTEK_LIBC__
snprintf(fios->name, lengthof(fios->name), "%c:", 'A' + disk - 1);
#else
snprintf(fios->name, lengthof(fios->name), "%c:", disk);
#endif
strecpy(fios->title, fios->name, lastof(fios->title));
}
}
/* Restore the original drive */
#ifndef __INNOTEK_LIBC__
_dos_setdrive(save, &total);
#else
chdir(wd);
#endif
}
bool FiosGetDiskFreeSpace(const char *path, uint64 *tot)
{
#ifndef __INNOTEK_LIBC__
struct diskfree_t free;
char drive = path[0] - 'A' + 1;
if (tot != NULL && _getdiskfree(drive, &free) == 0) {
*tot = free.avail_clusters * free.sectors_per_cluster * free.bytes_per_sector;
return true;
}
return false;
#else
uint64 free = 0;
#ifdef HAS_STATVFS
{
struct statvfs s;
if (statvfs(path, &s) != 0) return false;
free = (uint64)s.f_frsize * s.f_bavail;
}
#endif
if (tot != NULL) *tot = free;
return true;
#endif
}
bool FiosIsValidFile(const char *path, const struct dirent *ent, struct stat *sb)
{
char filename[MAX_PATH];
snprintf(filename, lengthof(filename), "%s" PATHSEP "%s", path, ent->d_name);
return stat(filename, sb) == 0;
}
int GetDiskParameter( char *path,
char *volume_name,
LONGLONG *avail_bytes,
LONGLONG *total_disk_space
)
{
#ifdef WIN32
struct _diskfree_t diskspace;
#else
#if defined( SVR4 ) || defined( OSF1 ) || defined( __NetBSD__ )
struct statvfs statfs_struct;
#else
#ifdef ultrix
struct fs_data statfs_struct;
#else
#ifdef QNX
long total_blocks, free_blocks;
int fd;
#else
struct statfs statfs_struct;
#endif /* QNX */
#endif /* ultrix */
#endif /* SVR4 */
#endif /* WIN32 */
char *p;
char *fname;
int result;
LONGLONG bfree;
LONGLONG this_disk_space;
#ifdef WIN32
if( ( result = _getdiskfree( 0, &diskspace ) ) == 0 )
#else
#ifdef __DJGPP__
if( ( result = statfs( path, &statfs_struct ) ) == 0 )
#else
#ifdef QNX
fd = open(path, O_RDONLY );
if( ( result = disk_space( fd, &free_blocks, &total_blocks ) ) == 0 )
#else
if( ( result = STATFS( path, &statfs_struct, sizeof( statfs_struct ), 0 ) ) == 0 )
#endif /* QNX */
#endif /* __DJGPP__ */
#endif /* WIN32 */
{
if( volume_name )
{
/* Name ermitteln */
/*----------------*/
if( mode == DISK_MODE || mode == USER_MODE )
{
#ifdef linux
switch( statfs_struct.f_type ) {
case 0xEF51:
fname = "EXT2-OLD"; break;
case 0xEF53:
fname = "EXT2"; break;
case 0x137D:
fname = "EXT"; break;
case 0x9660:
fname = "ISOFS"; break;
case 0x137F:
fname = "MINIX"; break;
case 0x138F:
fname = "MINIX2"; break;
case 0x2468:
fname = "MINIX-NEW"; break;
case 0x4d44:
fname = "DOS"; break;
case 0x6969:
fname = "NFS"; break;
case 0x9fa0:
fname = "PROC"; break;
case 0x012FD16D:
fname = "XIAFS"; break;
default:
fname = "LINUX";
}
#else
#ifdef __GNU__
switch( statfs_struct.f_type ) {
case FSTYPE_UFS:
fname = "UFS"; break;
case FSTYPE_NFS:
fname = "NFS"; break;
case FSTYPE_GFS:
fname = "GFS"; break;
case FSTYPE_LFS:
fname = "LFS"; break;
case FSTYPE_SYSV:
fname = "SYSV"; break;
case FSTYPE_FTP:
fname = "FTP"; break;
case FSTYPE_TAR:
fname = "TAR"; break;
case FSTYPE_AR:
fname = "AR"; break;
case FSTYPE_CPIO:
fname = "CPIO"; break;
case FSTYPE_MSLOSS:
fname = "DOS"; break;
case FSTYPE_CPM:
fname = "CPM"; break;
case FSTYPE_HFS:
fname = "HFS"; break;
case FSTYPE_DTFS:
fname = "DTFS"; break;
case FSTYPE_GRFS:
fname = "GRFS"; break;
case FSTYPE_TERM:
fname = "TERM"; break;
case FSTYPE_DEV:
fname = "DEV"; break;
case FSTYPE_PROC:
fname = "PROC"; break;
case FSTYPE_IFSOCK:
fname = "IFSOCK"; break;
case FSTYPE_AFS:
fname = "AFS"; break;
case FSTYPE_DFS:
fname = "DFS"; break;
case FSTYPE_PROC9:
fname = "PROC9"; break;
case FSTYPE_SOCKET:
fname = "SOCKET"; break;
case FSTYPE_MISC:
fname = "MISC"; break;
case FSTYPE_EXT2FS:
fname = "EXT2FS"; break;
case FSTYPE_HTTP:
fname = "HTTP"; break;
case FSTYPE_MEMFS:
fname = "MEM"; break;
case FSTYPE_ISO9660:
fname = "ISO9660"; break;
default:
fname = "HURD";
}
#else
#if defined( sun56 ) || defined( sun ) || defined( hpux ) || defined( __NeXT__ ) || defined( ultrix ) || defined ( __FreeBSD__ ) || defined (__APPLE__)
fname = "UNIX";
#else
#ifdef WIN32
fname = "WIN-NT";
#else
#ifdef __DJGPP__
fname = "DJGPP";
#else
#ifdef QNX
fname = "QNX";
#else
#if defined( SVR4 ) || defined( OSF1 )
fname = statfs_struct.f_fstr;
#else
#if defined(__OpenBSD__) || defined(__NetBSD__)
fname = statfs_struct.f_fstypename;
#else
fname = statfs_struct.f_fname;
#endif /* __OpenBSD__ || __NetBSD__ */
#endif /* SVR4 */
#endif /* __DJGPP__ */
#endif /* QNX */
#endif /* WIN32 */
#endif /* sun / hpux / __NeXT__ ultrix */
#endif /* __GNU__ */
#endif /* linux */
(void) strncpy( volume_name,
fname,
MINIMUM( DISK_NAME_LENGTH, strlen( fname ) )
);
volume_name[ MINIMUM( DISK_NAME_LENGTH, strlen( fname ))] = '\0';
}
else
{
/* TAR/ZOO/ZIP-FILE_MODE */
/*-----------------------*/
if( ( p = strrchr( statistic.login_path, FILE_SEPARATOR_CHAR ) ) == NULL )
p = statistic.login_path;
else p++;
(void) strncpy( volume_name, p, sizeof( statistic.disk_name ) );
volume_name[sizeof( statistic.disk_name )] = '\0';
}
} /* volume_name */
#ifdef WIN32
*avail_bytes = (long) diskspace.bytes_per_sector *
(long) diskspace.sectors_per_cluster *
(long) diskspace.avail_clusters;
this_disk_space = 900000000L; /* for now.. */
#else
#if (defined( SVR4 ) || defined( OSF1 )) && !defined( __DGUX__ )
bfree = getuid() ? statfs_struct.f_bavail : statfs_struct.f_bfree;
if( bfree < 0L ) bfree = 0L;
*avail_bytes = bfree * statfs_struct.f_frsize;
this_disk_space = statfs_struct.f_blocks * statfs_struct.f_frsize;
#else
#if defined( _IBMR2 ) || defined( linux ) || defined( sun ) || defined( __NeXT__ ) || defined( __GNU__ )
bfree = getuid() ? statfs_struct.f_bavail : statfs_struct.f_bfree;
if( bfree < 0L ) bfree = 0L;
*avail_bytes = bfree * statfs_struct.f_bsize;
this_disk_space = statfs_struct.f_blocks * statfs_struct.f_blocks;
#else
#ifdef SVR3
bfree = statfs_struct.f_bfree;
if( bfree < 0L ) bfree = 0L;
*avail_bytes = bfree * BLKSIZ; /* SYSV */
this_disk_space = statfs_struct.f_blocks * BLKSIZ;
#else
#if defined( ultrix )
bfree = statfs_struct.fd_req.bfree;
if( bfree < 0L ) bfree = 0L;
#else
#if defined( QNX )
*avail_bytes = free_blocks * 512;
this_disk_space = total_blocks * 512;
#else
bfree = statfs_struct.f_bfree;
if( bfree < 0L ) bfree = 0L;
*avail_bytes = bfree * statfs_struct.f_bsize;
this_disk_space = statfs_struct.f_blocks * statfs_struct.f_bsize;
#endif /* QNX */
#endif /* ultrix */
#endif /* SVR3 */
#endif /* SVR4/!__DGUX__ */
#endif /* _IBMR2/linux/sun/__NeXT__/__GNU__ */
#endif /* WIN32 */
if( total_disk_space )
{
*total_disk_space = this_disk_space;
}
}
#ifdef QNX
close(fd);
#endif
return( result );
}
