react-native-update 10.34.2 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/FileFind.h

@@ -0,0 +1,161 @@
+// Windows/FileFind.h
+
+#ifndef __WINDOWS_FILE_FIND_H
+#define __WINDOWS_FILE_FIND_H
+
+#include "../Common/MyString.h"
+#include "Defs.h"
+
+namespace NWindows {
+namespace NFile {
+namespace NFind {
+
+namespace NAttributes
+{
+  inline bool IsReadOnly(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_READONLY) != 0; }
+  inline bool IsHidden(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_HIDDEN) != 0; }
+  inline bool IsSystem(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_SYSTEM) != 0; }
+  inline bool IsDir(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0; }
+  inline bool IsArchived(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ARCHIVE) != 0; }
+  inline bool IsCompressed(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_COMPRESSED) != 0; }
+  inline bool IsEncrypted(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ENCRYPTED) != 0; }
+}
+
+class CFileInfoBase
+{
+  bool MatchesMask(UINT32 mask) const { return ((Attrib & mask) != 0); }
+public:
+  UInt64 Size;
+  FILETIME CTime;
+  FILETIME ATime;
+  FILETIME MTime;
+  DWORD Attrib;
+  bool IsAltStream;
+  bool IsDevice;
+
+  /*
+  #ifdef UNDER_CE
+  DWORD ObjectID;
+  #else
+  UINT32 ReparseTag;
+  #endif
+  */
+
+  CFileInfoBase() { ClearBase(); }
+  void ClearBase() throw();
+
+  void SetAsDir() { Attrib = FILE_ATTRIBUTE_DIRECTORY; }
+
+  bool IsArchived() const { return MatchesMask(FILE_ATTRIBUTE_ARCHIVE); }
+  bool IsCompressed() const { return MatchesMask(FILE_ATTRIBUTE_COMPRESSED); }
+  bool IsDir() const { return MatchesMask(FILE_ATTRIBUTE_DIRECTORY); }
+  bool IsEncrypted() const { return MatchesMask(FILE_ATTRIBUTE_ENCRYPTED); }
+  bool IsHidden() const { return MatchesMask(FILE_ATTRIBUTE_HIDDEN); }
+  bool IsNormal() const { return MatchesMask(FILE_ATTRIBUTE_NORMAL); }
+  bool IsOffline() const { return MatchesMask(FILE_ATTRIBUTE_OFFLINE); }
+  bool IsReadOnly() const { return MatchesMask(FILE_ATTRIBUTE_READONLY); }
+  bool HasReparsePoint() const { return MatchesMask(FILE_ATTRIBUTE_REPARSE_POINT); }
+  bool IsSparse() const { return MatchesMask(FILE_ATTRIBUTE_SPARSE_FILE); }
+  bool IsSystem() const { return MatchesMask(FILE_ATTRIBUTE_SYSTEM); }
+  bool IsTemporary() const { return MatchesMask(FILE_ATTRIBUTE_TEMPORARY); }
+};
+
+struct CFileInfo: public CFileInfoBase
+{
+  FString Name;
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  // FString ShortName;
+  #endif
+
+  bool IsDots() const throw();
+  bool Find(CFSTR path);
+};
+
+class CFindFileBase
+{
+protected:
+  HANDLE _handle;
+public:
+  bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE; }
+  CFindFileBase(): _handle(INVALID_HANDLE_VALUE) {}
+  ~CFindFileBase() { Close(); }
+  bool Close() throw();
+};
+
+class CFindFile: public CFindFileBase
+{
+public:
+  bool FindFirst(CFSTR wildcard, CFileInfo &fileInfo);
+  bool FindNext(CFileInfo &fileInfo);
+};
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+struct CStreamInfo
+{
+  UString Name;
+  UInt64 Size;
+
+  UString GetReducedName() const; // returns ":Name"
+  // UString GetReducedName2() const; // returns "Name"
+  bool IsMainStream() const throw();
+};
+
+class CFindStream: public CFindFileBase
+{
+public:
+  bool FindFirst(CFSTR filePath, CStreamInfo &streamInfo);
+  bool FindNext(CStreamInfo &streamInfo);
+};
+
+class CStreamEnumerator
+{
+  CFindStream _find;
+  FString _filePath;
+
+  bool NextAny(CFileInfo &fileInfo);
+public:
+  CStreamEnumerator(const FString &filePath): _filePath(filePath) {}
+  bool Next(CStreamInfo &streamInfo, bool &found);
+};
+
+#endif
+
+bool DoesFileExist(CFSTR name);
+bool DoesDirExist(CFSTR name);
+bool DoesFileOrDirExist(CFSTR name);
+
+DWORD GetFileAttrib(CFSTR path);
+
+class CEnumerator
+{
+  CFindFile _findFile;
+  FString _wildcard;
+
+  bool NextAny(CFileInfo &fileInfo);
+public:
+  void SetDirPrefix(const FString &dirPrefix);
+  bool Next(CFileInfo &fileInfo);
+  bool Next(CFileInfo &fileInfo, bool &found);
+};
+
+class CFindChangeNotification
+{
+  HANDLE _handle;
+public:
+  operator HANDLE () { return _handle; }
+  bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE && _handle != 0; }
+  CFindChangeNotification(): _handle(INVALID_HANDLE_VALUE) {}
+  ~CFindChangeNotification() { Close(); }
+  bool Close() throw();
+  HANDLE FindFirst(CFSTR pathName, bool watchSubtree, DWORD notifyFilter);
+  bool FindNext() { return BOOLToBool(::FindNextChangeNotification(_handle)); }
+};
+
+#ifndef UNDER_CE
+bool MyGetLogicalDriveStrings(CObjectVector<FString> &driveStrings);
+#endif
+
+}}}
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/FileIO.cpp

@@ -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();
+}
+
+}}}