// Windows/FileIO.cpp



#include "StdAfx.h"



#include "FileIO.h"



#if defined(WIN_LONG_PATH) || defined(SUPPORT_DEVICE_FILE)

#include "../Common/MyString.h"

#endif

#ifndef _UNICODE

#include "../Common/StringConvert.h"

#endif



#ifndef _UNICODE

extern bool g_IsNT;

#endif



namespace NWindows {

namespace NFile {



#ifdef SUPPORT_DEVICE_FILE

bool IsDeviceName(LPCTSTR n)

{

  #ifdef UNDER_CE

  int len = (int)MyStringLen(n);

  if (len < 5 || len > 5 || memcmp(n, TEXT("DSK"), 3 * sizeof(TCHAR)) != 0)

    return false;

  if (n[4] != ':')

    return false;

  // for reading use SG_REQ sg; if (DeviceIoControl(dsk, IOCTL_DISK_READ));

  #else

  if (n[0] != '\\' || n[1] != '\\' || n[2] != '.' ||  n[3] != '\\')

    return false;

  int len = (int)MyStringLen(n);

  if (len == 6 && n[5] == ':')

    return true;

  if (len < 18 || len > 22 || memcmp(n + 4, TEXT("PhysicalDrive"), 13 * sizeof(TCHAR)) != 0)

    return false;

  for (int i = 17; i < len; i++)

    if (n[i] < '0' || n[i] > '9')

      return false;

  #endif

  return true;

}



#ifndef _UNICODE

bool IsDeviceName(LPCWSTR n)

{

  if (n[0] != '\\' || n[1] != '\\' || n[2] != '.' ||  n[3] != '\\')

    return false;

  int len = (int)wcslen(n);

  if (len == 6 && n[5] == ':')

    return true;

  if (len < 18 || len > 22 || wcsncmp(n + 4, L"PhysicalDrive", 13) != 0)

    return false;

  for (int i = 17; i < len; i++)

    if (n[i] < '0' || n[i] > '9')

      return false;

  return true;

}

#endif

#endif



#if defined(WIN_LONG_PATH) && defined(_UNICODE)

#define WIN_LONG_PATH2

#endif



#ifdef WIN_LONG_PATH

bool GetLongPathBase(LPCWSTR s, UString &res)

{

  res.Empty();

  int len = MyStringLen(s);

  wchar_t c = s[0];

  if (len < 1 || c == L'\\' || c == L'.' && (len == 1 || len == 2 && s[1] == L'.'))

    return true;

  UString curDir;

  bool isAbs = false;

  if (len > 3)

    isAbs = (s[1] == L':' && s[2] == L'\\' && (c >= L'a' && c <= L'z' || c >= L'A' && c <= L'Z'));



  if (!isAbs)

    {

      DWORD needLength = ::GetCurrentDirectoryW(MAX_PATH + 1, curDir.GetBuffer(MAX_PATH + 1));

      curDir.ReleaseBuffer();

      if (needLength == 0 || needLength > MAX_PATH)

        return false;

      if (curDir[curDir.Length() - 1] != L'\\')

        curDir += L'\\';

    }

  res = UString(L"\\\\?\\") + curDir + s;

  return true;

}



bool GetLongPath(LPCWSTR path, UString &longPath)

{

  if (GetLongPathBase(path, longPath))

    return !longPath.IsEmpty();

  return false;

}

#endif



namespace NIO {



CFileBase::~CFileBase() { Close(); }



bool CFileBase::Create(LPCTSTR fileName, DWORD desiredAccess,

    DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)

{

  if (!Close())

    return false;

  _handle = ::CreateFile(fileName, desiredAccess, shareMode,

      (LPSECURITY_ATTRIBUTES)NULL, creationDisposition,

      flagsAndAttributes, (HANDLE)NULL);

  #ifdef WIN_LONG_PATH2

  if (_handle == INVALID_HANDLE_VALUE)

  {

    UString longPath;

    if (GetLongPath(fileName, longPath))

      _handle = ::CreateFileW(longPath, desiredAccess, shareMode,

        (LPSECURITY_ATTRIBUTES)NULL, creationDisposition,

        flagsAndAttributes, (HANDLE)NULL);

  }

  #endif

  #ifdef SUPPORT_DEVICE_FILE

  IsDeviceFile = false;

  #endif

  return (_handle != INVALID_HANDLE_VALUE);

}



#ifndef _UNICODE

bool CFileBase::Create(LPCWSTR fileName, DWORD desiredAccess,

    DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)

{

  if (!g_IsNT)

    return Create(UnicodeStringToMultiByte(fileName, ::AreFileApisANSI() ? CP_ACP : CP_OEMCP),

      desiredAccess, shareMode, creationDisposition, flagsAndAttributes);

  if (!Close())

    return false;

  _handle = ::CreateFileW(fileName, desiredAccess, shareMode,

    (LPSECURITY_ATTRIBUTES)NULL, creationDisposition,

    flagsAndAttributes, (HANDLE)NULL);

  #ifdef WIN_LONG_PATH

  if (_handle == INVALID_HANDLE_VALUE)

  {

    UString longPath;

    if (GetLongPath(fileName, longPath))

      _handle = ::CreateFileW(longPath, desiredAccess, shareMode,

        (LPSECURITY_ATTRIBUTES)NULL, creationDisposition,

        flagsAndAttributes, (HANDLE)NULL);

  }

  #endif

  #ifdef SUPPORT_DEVICE_FILE

  IsDeviceFile = false;

  #endif

  return (_handle != INVALID_HANDLE_VALUE);

}

#endif



bool CFileBase::Close()

{

  if (_handle == INVALID_HANDLE_VALUE)

    return true;

  if (!::CloseHandle(_handle))

    return false;

  _handle = INVALID_HANDLE_VALUE;

  return true;

}



bool CFileBase::GetPosition(UInt64 &position) const

{

  return Seek(0, FILE_CURRENT, position);

}



bool CFileBase::GetLength(UInt64 &length) const

{

  #ifdef SUPPORT_DEVICE_FILE

  if (IsDeviceFile && LengthDefined)

  {

    length = Length;

    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

{

  #ifdef SUPPORT_DEVICE_FILE

  if (IsDeviceFile && LengthDefined && moveMethod == FILE_END)

  {

    distanceToMove += Length;

    moveMethod = FILE_BEGIN;

  }

  #endif



  LARGE_INTEGER value;

  value.QuadPart = distanceToMove;

  value.LowPart = ::SetFilePointer(_handle, value.LowPart, &value.HighPart, moveMethod);

  if (value.LowPart == 0xFFFFFFFF)

    if (::GetLastError() != NO_ERROR)

      return false;

  newPosition = value.QuadPart;

  return true;

}



bool CFileBase::Seek(UInt64 position, UInt64 &newPosition)

{

  return Seek(position, FILE_BEGIN, newPosition);

}



bool CFileBase::SeekToBegin()

{

  UInt64 newPosition;

  return Seek(0, newPosition);

}



bool CFileBase::SeekToEnd(UInt64 &newPosition)

{

  return Seek(0, FILE_END, newPosition);

}



bool CFileBase::GetFileInformation(CByHandleFileInfo &fileInfo) const

{

  BY_HANDLE_FILE_INFORMATION winFileInfo;

  if (!::GetFileInformationByHandle(_handle, &winFileInfo))

    return false;

  fileInfo.Attrib = winFileInfo.dwFileAttributes;

  fileInfo.CTime = winFileInfo.ftCreationTime;

  fileInfo.ATime = winFileInfo.ftLastAccessTime;

  fileInfo.MTime = winFileInfo.ftLastWriteTime;

  fileInfo.VolumeSerialNumber = winFileInfo.dwFileAttributes;

  fileInfo.Size = (((UInt64)winFileInfo.nFileSizeHigh) << 32) +  winFileInfo.nFileSizeLow;

  fileInfo.NumberOfLinks = winFileInfo.nNumberOfLinks;

  fileInfo.FileIndex = (((UInt64)winFileInfo.nFileIndexHigh) << 32) + winFileInfo.nFileIndexLow;

  return true;

}



/////////////////////////

// CInFile



#ifdef SUPPORT_DEVICE_FILE

void CInFile::GetDeviceLength()

{

  if (_handle != INVALID_HANDLE_VALUE && IsDeviceFile)

  {

    #ifdef UNDER_CE

    LengthDefined = true;

    Length = 128 << 20;



    #else

    PARTITION_INFORMATION partInfo;

    LengthDefined = true;

    Length = 0;



    if (GetPartitionInfo(&partInfo))

      Length = partInfo.PartitionLength.QuadPart;

    else

    {

      DISK_GEOMETRY geom;

      if (!GetGeometry(&geom))

        if (!GetCdRomGeometry(&geom))

          LengthDefined = false;

      if (LengthDefined)

        Length = geom.Cylinders.QuadPart * geom.TracksPerCylinder * geom.SectorsPerTrack * geom.BytesPerSector;

    }

    // SeekToBegin();

    #endif

  }

}



// ((desiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA | GENERIC_WRITE)) == 0 &&



#define MY_DEVICE_EXTRA_CODE \

  IsDeviceFile = IsDeviceName(fileName); \

  GetDeviceLength();

#else

#define MY_DEVICE_EXTRA_CODE

#endif



bool CInFile::Open(LPCTSTR 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(LPCTSTR fileName, bool shareForWrite)

{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }



bool CInFile::Open(LPCTSTR fileName)

  { return OpenShared(fileName, false); }



#ifndef _UNICODE

bool CInFile::Open(LPCWSTR 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(LPCWSTR fileName, bool shareForWrite)

{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }



bool CInFile::Open(LPCWSTR fileName)

  { return OpenShared(fileName, false); }

#endif



// 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)

{

  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)

{

  if (size > kChunkSizeMax)

    size = kChunkSizeMax;

  return Read1(data, size, processedSize);

}



bool CInFile::Read(void *data, UInt32 size, UInt32 &processedSize)

{

  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



bool COutFile::Open(LPCTSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)

  { return CFileBase::Create(fileName, GENERIC_WRITE, shareMode, creationDisposition, flagsAndAttributes); }



static inline DWORD GetCreationDisposition(bool createAlways)

  { return createAlways? CREATE_ALWAYS: CREATE_NEW; }



bool COutFile::Open(LPCTSTR fileName, DWORD creationDisposition)

  { return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }



bool COutFile::Create(LPCTSTR fileName, bool createAlways)

  { return Open(fileName, GetCreationDisposition(createAlways)); }



#ifndef _UNICODE



bool COutFile::Open(LPCWSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)

  { return CFileBase::Create(fileName, GENERIC_WRITE, shareMode, creationDisposition, flagsAndAttributes); }



bool COutFile::Open(LPCWSTR fileName, DWORD creationDisposition)

  { return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }



bool COutFile::Create(LPCWSTR fileName, bool createAlways)

  { return Open(fileName, GetCreationDisposition(createAlways)); }



#endif



bool COutFile::SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime)

  { return BOOLToBool(::SetFileTime(_handle, cTime, aTime, mTime)); }



bool COutFile::SetMTime(const FILETIME *mTime) {  return SetTime(NULL, NULL, mTime); }



bool COutFile::WritePart(const void *data, UInt32 size, UInt32 &processedSize)

{

  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)

{

  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() { return BOOLToBool(::SetEndOfFile(_handle)); }



bool COutFile::SetLength(UInt64 length)

{

  UInt64 newPosition;

  if (!Seek(length, newPosition))

    return false;

  if (newPosition != length)

    return false;

  return SetEndOfFile();

}



}}}