mirror of
https://github.com/Xevion/easy7zip.git
synced 2025-12-09 00:07:00 -06:00
Initialer Commit
This commit is contained in:
Tino Reichardt
432
CPP/Windows/FileIO.cpp
Normal file
432
CPP/Windows/FileIO.cpp
Normal file
@@ -0,0 +1,432 @@
|
||||
// Windows/FileIO.cpp
|
||||
|
||||
#include "StdAfx.h"
|
||||
|
||||
#ifdef SUPPORT_DEVICE_FILE
|
||||
#include "../../C/Alloc.h"
|
||||
#endif
|
||||
|
||||
#include "FileIO.h"
|
||||
#include "FileName.h"
|
||||
|
||||
#ifndef _UNICODE
|
||||
extern bool g_IsNT;
|
||||
#endif
|
||||
|
||||
using namespace NWindows;
|
||||
using namespace NFile;
|
||||
using namespace NName;
|
||||
|
||||
namespace NWindows {
|
||||
namespace NFile {
|
||||
|
||||
#ifdef SUPPORT_DEVICE_FILE
|
||||
|
||||
namespace NSystem
|
||||
{
|
||||
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace NIO {
|
||||
|
||||
/*
|
||||
WinXP-64 CreateFile():
|
||||
"" - ERROR_PATH_NOT_FOUND
|
||||
:stream - OK
|
||||
.:stream - ERROR_PATH_NOT_FOUND
|
||||
.\:stream - OK
|
||||
|
||||
folder\:stream - ERROR_INVALID_NAME
|
||||
folder:stream - OK
|
||||
|
||||
c:\:stream - OK
|
||||
|
||||
c::stream - ERROR_INVALID_NAME, if current dir is NOT ROOT ( c:\dir1 )
|
||||
c::stream - OK, if current dir is ROOT ( c:\ )
|
||||
*/
|
||||
|
||||
bool CFileBase::Create(CFSTR path, DWORD desiredAccess,
|
||||
DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
|
||||
{
|
||||
if (!Close())
|
||||
return false;
|
||||
|
||||
#ifdef SUPPORT_DEVICE_FILE
|
||||
IsDeviceFile = false;
|
||||
#endif
|
||||
|
||||
#ifndef _UNICODE
|
||||
if (!g_IsNT)
|
||||
{
|
||||
_handle = ::CreateFile(fs2fas(path), desiredAccess, shareMode,
|
||||
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
IF_USE_MAIN_PATH
|
||||
_handle = ::CreateFileW(fs2us(path), desiredAccess, shareMode,
|
||||
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
|
||||
#ifdef WIN_LONG_PATH
|
||||
if (_handle == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
|
||||
{
|
||||
UString superPath;
|
||||
if (GetSuperPath(path, superPath, USE_MAIN_PATH))
|
||||
_handle = ::CreateFileW(superPath, desiredAccess, shareMode,
|
||||
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return (_handle != INVALID_HANDLE_VALUE);
|
||||
}
|
||||
|
||||
bool CFileBase::Close() throw()
|
||||
{
|
||||
if (_handle == INVALID_HANDLE_VALUE)
|
||||
return true;
|
||||
if (!::CloseHandle(_handle))
|
||||
return false;
|
||||
_handle = INVALID_HANDLE_VALUE;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CFileBase::GetPosition(UInt64 &position) const throw()
|
||||
{
|
||||
return Seek(0, FILE_CURRENT, position);
|
||||
}
|
||||
|
||||
bool CFileBase::GetLength(UInt64 &length) const throw()
|
||||
{
|
||||
#ifdef SUPPORT_DEVICE_FILE
|
||||
if (IsDeviceFile && SizeDefined)
|
||||
{
|
||||
length = Size;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
DWORD sizeHigh;
|
||||
DWORD sizeLow = ::GetFileSize(_handle, &sizeHigh);
|
||||
if (sizeLow == 0xFFFFFFFF)
|
||||
if (::GetLastError() != NO_ERROR)
|
||||
return false;
|
||||
length = (((UInt64)sizeHigh) << 32) + sizeLow;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CFileBase::Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw()
|
||||
{
|
||||
#ifdef SUPPORT_DEVICE_FILE
|
||||
if (IsDeviceFile && SizeDefined && moveMethod == FILE_END)
|
||||
{
|
||||
distanceToMove += Size;
|
||||
moveMethod = FILE_BEGIN;
|
||||
}
|
||||
#endif
|
||||
|
||||
LONG high = (LONG)(distanceToMove >> 32);
|
||||
DWORD low = ::SetFilePointer(_handle, (LONG)(distanceToMove & 0xFFFFFFFF), &high, moveMethod);
|
||||
if (low == 0xFFFFFFFF)
|
||||
if (::GetLastError() != NO_ERROR)
|
||||
return false;
|
||||
newPosition = (((UInt64)(UInt32)high) << 32) + low;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CFileBase::Seek(UInt64 position, UInt64 &newPosition) const throw()
|
||||
{
|
||||
return Seek(position, FILE_BEGIN, newPosition);
|
||||
}
|
||||
|
||||
bool CFileBase::SeekToBegin() const throw()
|
||||
{
|
||||
UInt64 newPosition;
|
||||
return Seek(0, newPosition);
|
||||
}
|
||||
|
||||
bool CFileBase::SeekToEnd(UInt64 &newPosition) const throw()
|
||||
{
|
||||
return Seek(0, FILE_END, newPosition);
|
||||
}
|
||||
|
||||
// ---------- CInFile ---------
|
||||
|
||||
#ifdef SUPPORT_DEVICE_FILE
|
||||
|
||||
void CInFile::CorrectDeviceSize()
|
||||
{
|
||||
// maybe we must decrease kClusterSize to 1 << 12, if we want correct size at tail
|
||||
static const UInt32 kClusterSize = 1 << 14;
|
||||
UInt64 pos = Size & ~(UInt64)(kClusterSize - 1);
|
||||
UInt64 realNewPosition;
|
||||
if (!Seek(pos, realNewPosition))
|
||||
return;
|
||||
Byte *buf = (Byte *)MidAlloc(kClusterSize);
|
||||
|
||||
bool needbackward = true;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
UInt32 processed = 0;
|
||||
// up test is slow for "PhysicalDrive".
|
||||
// processed size for latest block for "PhysicalDrive0" is 0.
|
||||
if (!Read1(buf, kClusterSize, processed))
|
||||
break;
|
||||
if (processed == 0)
|
||||
break;
|
||||
needbackward = false;
|
||||
Size = pos + processed;
|
||||
if (processed != kClusterSize)
|
||||
break;
|
||||
pos += kClusterSize;
|
||||
}
|
||||
|
||||
if (needbackward && pos != 0)
|
||||
{
|
||||
pos -= kClusterSize;
|
||||
for (;;)
|
||||
{
|
||||
// break;
|
||||
if (!Seek(pos, realNewPosition))
|
||||
break;
|
||||
if (!buf)
|
||||
{
|
||||
buf = (Byte *)MidAlloc(kClusterSize);
|
||||
if (!buf)
|
||||
break;
|
||||
}
|
||||
UInt32 processed = 0;
|
||||
// that code doesn't work for "PhysicalDrive0"
|
||||
if (!Read1(buf, kClusterSize, processed))
|
||||
break;
|
||||
if (processed != 0)
|
||||
{
|
||||
Size = pos + processed;
|
||||
break;
|
||||
}
|
||||
if (pos == 0)
|
||||
break;
|
||||
pos -= kClusterSize;
|
||||
}
|
||||
}
|
||||
MidFree(buf);
|
||||
}
|
||||
|
||||
|
||||
void CInFile::CalcDeviceSize(CFSTR s)
|
||||
{
|
||||
SizeDefined = false;
|
||||
Size = 0;
|
||||
if (_handle == INVALID_HANDLE_VALUE || !IsDeviceFile)
|
||||
return;
|
||||
#ifdef UNDER_CE
|
||||
|
||||
SizeDefined = true;
|
||||
Size = 128 << 20;
|
||||
|
||||
#else
|
||||
|
||||
PARTITION_INFORMATION partInfo;
|
||||
bool needCorrectSize = true;
|
||||
|
||||
/*
|
||||
WinXP 64-bit:
|
||||
|
||||
HDD \\.\PhysicalDrive0 (MBR):
|
||||
GetPartitionInfo == GeometryEx : corrrect size? (includes tail)
|
||||
Geometry : smaller than GeometryEx (no tail, maybe correct too?)
|
||||
MyGetDiskFreeSpace : FAIL
|
||||
Size correction is slow and block size (kClusterSize) must be small?
|
||||
|
||||
HDD partition \\.\N: (NTFS):
|
||||
MyGetDiskFreeSpace : Size of NTFS clusters. Same size can be calculated after correction
|
||||
GetPartitionInfo : size of partition data: NTFS clusters + TAIL; TAIL contains extra empty sectors and copy of first sector of NTFS
|
||||
Geometry / CdRomGeometry / GeometryEx : size of HDD (not that partition)
|
||||
|
||||
CD-ROM drive (ISO):
|
||||
MyGetDiskFreeSpace : correct size. Same size can be calculated after correction
|
||||
Geometry == CdRomGeometry : smaller than corrrect size
|
||||
GetPartitionInfo == GeometryEx : larger than corrrect size
|
||||
|
||||
Floppy \\.\a: (FAT):
|
||||
Geometry : correct size.
|
||||
CdRomGeometry / GeometryEx / GetPartitionInfo / MyGetDiskFreeSpace - FAIL
|
||||
correction works OK for FAT.
|
||||
correction works OK for non-FAT, if kClusterSize = 512.
|
||||
*/
|
||||
|
||||
if (GetPartitionInfo(&partInfo))
|
||||
{
|
||||
Size = partInfo.PartitionLength.QuadPart;
|
||||
SizeDefined = true;
|
||||
needCorrectSize = false;
|
||||
if ((s)[0] == '\\' && (s)[1] == '\\' && (s)[2] == '.' && (s)[3] == '\\' && (s)[5] == ':' && (s)[6] == 0)
|
||||
{
|
||||
FChar path[4] = { s[4], ':', '\\', 0 };
|
||||
UInt64 clusterSize, totalSize, freeSize;
|
||||
if (NSystem::MyGetDiskFreeSpace(path, clusterSize, totalSize, freeSize))
|
||||
Size = totalSize;
|
||||
else
|
||||
needCorrectSize = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!SizeDefined)
|
||||
{
|
||||
my_DISK_GEOMETRY_EX geomEx;
|
||||
SizeDefined = GetGeometryEx(&geomEx);
|
||||
if (SizeDefined)
|
||||
Size = geomEx.DiskSize.QuadPart;
|
||||
else
|
||||
{
|
||||
DISK_GEOMETRY geom;
|
||||
SizeDefined = GetGeometry(&geom);
|
||||
if (!SizeDefined)
|
||||
SizeDefined = GetCdRomGeometry(&geom);
|
||||
if (SizeDefined)
|
||||
Size = geom.Cylinders.QuadPart * geom.TracksPerCylinder * geom.SectorsPerTrack * geom.BytesPerSector;
|
||||
}
|
||||
}
|
||||
|
||||
if (needCorrectSize && SizeDefined && Size != 0)
|
||||
{
|
||||
CorrectDeviceSize();
|
||||
SeekToBegin();
|
||||
}
|
||||
|
||||
// SeekToBegin();
|
||||
#endif
|
||||
}
|
||||
|
||||
// ((desiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA | GENERIC_WRITE)) == 0 &&
|
||||
|
||||
#define MY_DEVICE_EXTRA_CODE \
|
||||
IsDeviceFile = IsDevicePath(fileName); \
|
||||
CalcDeviceSize(fileName);
|
||||
#else
|
||||
#define MY_DEVICE_EXTRA_CODE
|
||||
#endif
|
||||
|
||||
bool CInFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
|
||||
{
|
||||
bool res = Create(fileName, GENERIC_READ, shareMode, creationDisposition, flagsAndAttributes);
|
||||
MY_DEVICE_EXTRA_CODE
|
||||
return res;
|
||||
}
|
||||
|
||||
bool CInFile::OpenShared(CFSTR fileName, bool shareForWrite)
|
||||
{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
|
||||
|
||||
bool CInFile::Open(CFSTR fileName)
|
||||
{ return OpenShared(fileName, false); }
|
||||
|
||||
// ReadFile and WriteFile functions in Windows have BUG:
|
||||
// If you Read or Write 64MB or more (probably min_failure_size = 64MB - 32KB + 1)
|
||||
// from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES
|
||||
// (Insufficient system resources exist to complete the requested service).
|
||||
|
||||
// Probably in some version of Windows there are problems with other sizes:
|
||||
// for 32 MB (maybe also for 16 MB).
|
||||
// And message can be "Network connection was lost"
|
||||
|
||||
static UInt32 kChunkSizeMax = (1 << 22);
|
||||
|
||||
bool CInFile::Read1(void *data, UInt32 size, UInt32 &processedSize) throw()
|
||||
{
|
||||
DWORD processedLoc = 0;
|
||||
bool res = BOOLToBool(::ReadFile(_handle, data, size, &processedLoc, NULL));
|
||||
processedSize = (UInt32)processedLoc;
|
||||
return res;
|
||||
}
|
||||
|
||||
bool CInFile::ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw()
|
||||
{
|
||||
if (size > kChunkSizeMax)
|
||||
size = kChunkSizeMax;
|
||||
return Read1(data, size, processedSize);
|
||||
}
|
||||
|
||||
bool CInFile::Read(void *data, UInt32 size, UInt32 &processedSize) throw()
|
||||
{
|
||||
processedSize = 0;
|
||||
do
|
||||
{
|
||||
UInt32 processedLoc = 0;
|
||||
bool res = ReadPart(data, size, processedLoc);
|
||||
processedSize += processedLoc;
|
||||
if (!res)
|
||||
return false;
|
||||
if (processedLoc == 0)
|
||||
return true;
|
||||
data = (void *)((unsigned char *)data + processedLoc);
|
||||
size -= processedLoc;
|
||||
}
|
||||
while (size > 0);
|
||||
return true;
|
||||
}
|
||||
|
||||
// ---------- COutFile ---------
|
||||
|
||||
static inline DWORD GetCreationDisposition(bool createAlways)
|
||||
{ return createAlways? CREATE_ALWAYS: CREATE_NEW; }
|
||||
|
||||
bool COutFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
|
||||
{ return CFileBase::Create(fileName, GENERIC_WRITE, shareMode, creationDisposition, flagsAndAttributes); }
|
||||
|
||||
bool COutFile::Open(CFSTR fileName, DWORD creationDisposition)
|
||||
{ return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }
|
||||
|
||||
bool COutFile::Create(CFSTR fileName, bool createAlways)
|
||||
{ return Open(fileName, GetCreationDisposition(createAlways)); }
|
||||
|
||||
bool COutFile::CreateAlways(CFSTR fileName, DWORD flagsAndAttributes)
|
||||
{ return Open(fileName, FILE_SHARE_READ, GetCreationDisposition(true), flagsAndAttributes); }
|
||||
|
||||
bool COutFile::SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime) throw()
|
||||
{ return BOOLToBool(::SetFileTime(_handle, cTime, aTime, mTime)); }
|
||||
|
||||
bool COutFile::SetMTime(const FILETIME *mTime) throw() { return SetTime(NULL, NULL, mTime); }
|
||||
|
||||
bool COutFile::WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw()
|
||||
{
|
||||
if (size > kChunkSizeMax)
|
||||
size = kChunkSizeMax;
|
||||
DWORD processedLoc = 0;
|
||||
bool res = BOOLToBool(::WriteFile(_handle, data, size, &processedLoc, NULL));
|
||||
processedSize = (UInt32)processedLoc;
|
||||
return res;
|
||||
}
|
||||
|
||||
bool COutFile::Write(const void *data, UInt32 size, UInt32 &processedSize) throw()
|
||||
{
|
||||
processedSize = 0;
|
||||
do
|
||||
{
|
||||
UInt32 processedLoc = 0;
|
||||
bool res = WritePart(data, size, processedLoc);
|
||||
processedSize += processedLoc;
|
||||
if (!res)
|
||||
return false;
|
||||
if (processedLoc == 0)
|
||||
return true;
|
||||
data = (const void *)((const unsigned char *)data + processedLoc);
|
||||
size -= processedLoc;
|
||||
}
|
||||
while (size > 0);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool COutFile::SetEndOfFile() throw() { return BOOLToBool(::SetEndOfFile(_handle)); }
|
||||
|
||||
bool COutFile::SetLength(UInt64 length) throw()
|
||||
{
|
||||
UInt64 newPosition;
|
||||
if (!Seek(length, newPosition))
|
||||
return false;
|
||||
if (newPosition != length)
|
||||
return false;
|
||||
return SetEndOfFile();
|
||||
}
|
||||
|
||||
}}}
|
||||
Reference in New Issue
Block a user