react-native-update 10.34.2 → 10.34.4

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

@@ -0,0 +1,115 @@
+// Windows/FileName.h
+
+#ifndef __WINDOWS_FILE_NAME_H
+#define __WINDOWS_FILE_NAME_H
+
+#include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NFile {
+namespace NName {
+
+int FindSepar(const wchar_t *s) throw();
+#ifndef USE_UNICODE_FSTRING
+int FindSepar(const FChar *s) throw();
+#endif
+
+void NormalizeDirPathPrefix(FString &dirPath); // ensures that it ended with '\\', if dirPath is not epmty
+void NormalizeDirPathPrefix(UString &dirPath);
+
+bool IsDrivePath(const wchar_t *s) throw();  // first 3 chars are drive chars like "a:\\"
+
+bool IsAltPathPrefix(CFSTR s) throw(); /* name: */
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+extern const char * const kSuperPathPrefix; /* \\?\ */
+const unsigned kDevicePathPrefixSize = 4;
+const unsigned kSuperPathPrefixSize = 4;
+const unsigned kSuperUncPathPrefixSize = kSuperPathPrefixSize + 4;
+
+bool IsDevicePath(CFSTR s) throw();   /* \\.\ */
+bool IsSuperUncPath(CFSTR s) throw(); /* \\?\UNC\ */
+bool IsNetworkPath(CFSTR s) throw();  /* \\?\UNC\ or \\SERVER */
+
+/* GetNetworkServerPrefixSize() returns size of server prefix:
+     \\?\UNC\SERVER\
+     \\SERVER\
+  in another cases it returns 0
+*/
+
+unsigned GetNetworkServerPrefixSize(CFSTR s) throw();
+
+bool IsNetworkShareRootPath(CFSTR s) throw();  /* \\?\UNC\SERVER\share or \\SERVER\share or with slash */
+
+bool IsDrivePath_SuperAllowed(CFSTR s) throw();  // first chars are drive chars like "a:\" or "\\?\a:\"
+bool IsDriveRootPath_SuperAllowed(CFSTR s) throw();  // exact drive root path "a:\" or "\\?\a:\"
+
+bool IsDrivePath2(const wchar_t *s) throw(); // first 2 chars are drive chars like "a:"
+// bool IsDriveName2(const wchar_t *s) throw(); // is drive name like "a:"
+bool IsSuperPath(const wchar_t *s) throw();
+bool IsSuperOrDevicePath(const wchar_t *s) throw();
+
+#ifndef USE_UNICODE_FSTRING
+bool IsDrivePath2(CFSTR s) throw(); // first 2 chars are drive chars like "a:"
+// bool IsDriveName2(CFSTR s) throw(); // is drive name like "a:"
+bool IsDrivePath(CFSTR s) throw();
+bool IsSuperPath(CFSTR s) throw();
+bool IsSuperOrDevicePath(CFSTR s) throw();
+
+/* GetRootPrefixSize() returns size of ROOT PREFIX for cases:
+     \
+     \\.\
+     C:\
+     \\?\C:\
+     \\?\UNC\SERVER\Shared\
+     \\SERVER\Shared\
+  in another cases it returns 0
+*/
+
+unsigned GetRootPrefixSize(CFSTR s) throw();
+
+#endif
+
+int FindAltStreamColon(CFSTR path) throw();
+
+#endif // _WIN32
+
+bool IsAbsolutePath(const wchar_t *s) throw();
+unsigned GetRootPrefixSize(const wchar_t *s) throw();
+
+#ifdef WIN_LONG_PATH
+
+const int kSuperPathType_UseOnlyMain = 0;
+const int kSuperPathType_UseOnlySuper = 1;
+const int kSuperPathType_UseMainAndSuper = 2;
+
+int GetUseSuperPathType(CFSTR s) throw();
+bool GetSuperPath(CFSTR path, UString &superPath, bool onlyIfNew);
+bool GetSuperPaths(CFSTR s1, CFSTR s2, UString &d1, UString &d2, bool onlyIfNew);
+
+#define USE_MAIN_PATH (__useSuperPathType != kSuperPathType_UseOnlySuper)
+#define USE_MAIN_PATH_2 (__useSuperPathType1 != kSuperPathType_UseOnlySuper && __useSuperPathType2 != kSuperPathType_UseOnlySuper)
+
+#define USE_SUPER_PATH (__useSuperPathType != kSuperPathType_UseOnlyMain)
+#define USE_SUPER_PATH_2 (__useSuperPathType1 != kSuperPathType_UseOnlyMain || __useSuperPathType2 != kSuperPathType_UseOnlyMain)
+
+#define IF_USE_MAIN_PATH int __useSuperPathType = GetUseSuperPathType(path); if (USE_MAIN_PATH)
+#define IF_USE_MAIN_PATH_2(x1, x2) \
+    int __useSuperPathType1 = GetUseSuperPathType(x1); \
+    int __useSuperPathType2 = GetUseSuperPathType(x2); \
+    if (USE_MAIN_PATH_2)
+
+#else
+
+#define IF_USE_MAIN_PATH
+#define IF_USE_MAIN_PATH_2(x1, x2)
+
+#endif // WIN_LONG_PATH
+
+bool GetFullPath(CFSTR dirPrefix, CFSTR path, FString &fullPath);
+bool GetFullPath(CFSTR path, FString &fullPath);
+
+}}}
+
+#endif

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

@@ -0,0 +1,131 @@
+// Windows/FileSystem.cpp
+
+#include "StdAfx.h"
+
+#ifndef UNDER_CE
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "FileSystem.h"
+#include "Defs.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NFile {
+namespace NSystem {
+
+bool MyGetVolumeInformation(
+    CFSTR rootPath,
+    UString &volumeName,
+    LPDWORD volumeSerialNumber,
+    LPDWORD maximumComponentLength,
+    LPDWORD fileSystemFlags,
+    UString &fileSystemName)
+{
+  BOOL res;
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    TCHAR v[MAX_PATH + 2]; v[0] = 0;
+    TCHAR f[MAX_PATH + 2]; f[0] = 0;
+    res = GetVolumeInformation(fs2fas(rootPath),
+        v, MAX_PATH,
+        volumeSerialNumber, maximumComponentLength, fileSystemFlags,
+        f, MAX_PATH);
+    volumeName = MultiByteToUnicodeString(v);
+    fileSystemName = MultiByteToUnicodeString(f);
+  }
+  else
+  #endif
+  {
+    WCHAR v[MAX_PATH + 2]; v[0] = 0;
+    WCHAR f[MAX_PATH + 2]; f[0] = 0;
+    res = GetVolumeInformationW(fs2us(rootPath),
+        v, MAX_PATH,
+        volumeSerialNumber, maximumComponentLength, fileSystemFlags,
+        f, MAX_PATH);
+    volumeName = v;
+    fileSystemName = f;
+  }
+  return BOOLToBool(res);
+}
+
+UINT MyGetDriveType(CFSTR pathName)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    return GetDriveType(fs2fas(pathName));
+  }
+  else
+  #endif
+  {
+    return GetDriveTypeW(fs2us(pathName));
+  }
+}
+
+typedef BOOL (WINAPI * GetDiskFreeSpaceExA_Pointer)(
+  LPCSTR lpDirectoryName,                  // directory name
+  PULARGE_INTEGER lpFreeBytesAvailable,    // bytes available to caller
+  PULARGE_INTEGER lpTotalNumberOfBytes,    // bytes on disk
+  PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
+);
+
+typedef BOOL (WINAPI * GetDiskFreeSpaceExW_Pointer)(
+  LPCWSTR lpDirectoryName,                 // directory name
+  PULARGE_INTEGER lpFreeBytesAvailable,    // bytes available to caller
+  PULARGE_INTEGER lpTotalNumberOfBytes,    // bytes on disk
+  PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
+);
+
+bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize)
+{
+  DWORD numSectorsPerCluster, bytesPerSector, numFreeClusters, numClusters;
+  bool sizeIsDetected = false;
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    GetDiskFreeSpaceExA_Pointer pGetDiskFreeSpaceEx = (GetDiskFreeSpaceExA_Pointer)GetProcAddress(
+        GetModuleHandle(TEXT("kernel32.dll")), "GetDiskFreeSpaceExA");
+    if (pGetDiskFreeSpaceEx)
+    {
+      ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
+      sizeIsDetected = BOOLToBool(pGetDiskFreeSpaceEx(fs2fas(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
+      totalSize = totalSize2.QuadPart;
+      freeSize = freeSize2.QuadPart;
+    }
+    if (!::GetDiskFreeSpace(fs2fas(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
+      return false;
+  }
+  else
+  #endif
+  {
+    GetDiskFreeSpaceExW_Pointer pGetDiskFreeSpaceEx = (GetDiskFreeSpaceExW_Pointer)GetProcAddress(
+        GetModuleHandle(TEXT("kernel32.dll")), "GetDiskFreeSpaceExW");
+    if (pGetDiskFreeSpaceEx)
+    {
+      ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
+      sizeIsDetected = BOOLToBool(pGetDiskFreeSpaceEx(fs2us(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
+      totalSize = totalSize2.QuadPart;
+      freeSize = freeSize2.QuadPart;
+    }
+    if (!::GetDiskFreeSpaceW(fs2us(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
+      return false;
+  }
+  clusterSize = (UInt64)bytesPerSector * (UInt64)numSectorsPerCluster;
+  if (!sizeIsDetected)
+  {
+    totalSize = clusterSize * (UInt64)numClusters;
+    freeSize = clusterSize * (UInt64)numFreeClusters;
+  }
+  return true;
+}
+
+}}}
+
+#endif

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

@@ -0,0 +1,27 @@
+// Windows/FileSystem.h
+
+#ifndef __WINDOWS_FILE_SYSTEM_H
+#define __WINDOWS_FILE_SYSTEM_H
+
+#include "../Common/MyString.h"
+#include "../Common/MyTypes.h"
+
+namespace NWindows {
+namespace NFile {
+namespace NSystem {
+
+bool MyGetVolumeInformation(
+    CFSTR rootPath  ,
+    UString &volumeName,
+    LPDWORD volumeSerialNumber,
+    LPDWORD maximumComponentLength,
+    LPDWORD fileSystemFlags,
+    UString &fileSystemName);
+
+UINT MyGetDriveType(CFSTR pathName);
+
+bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
+
+}}}
+
+#endif

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

@@ -0,0 +1,37 @@
+// Windows/Handle.h
+
+#ifndef __WINDOWS_HANDLE_H
+#define __WINDOWS_HANDLE_H
+
+namespace NWindows {
+
+class CHandle
+{
+protected:
+  HANDLE _handle;
+public:
+  operator HANDLE() { return _handle; }
+  CHandle(): _handle(NULL) {}
+  ~CHandle() { Close(); }
+  bool IsCreated() const { return (_handle != NULL); }
+  bool Close()
+  {
+    if (_handle == NULL)
+      return true;
+    if (!::CloseHandle(_handle))
+      return false;
+    _handle = NULL;
+    return true;
+  }
+  void Attach(HANDLE handle) { _handle = handle; }
+  HANDLE Detach()
+  {
+    HANDLE handle = _handle;
+    _handle = NULL;
+    return handle;
+  }
+};
+
+}
+
+#endif

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

@@ -0,0 +1,112 @@
+// Windows/MemoryLock.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+#include "MemoryLock.h"
+
+namespace NWindows {
+namespace NSecurity {
+
+#ifndef UNDER_CE
+
+#ifdef _UNICODE
+#define MY_FUNC_SELECT(f) :: f
+#else
+#define MY_FUNC_SELECT(f) my_ ## f
+extern "C" {
+typedef BOOL (WINAPI * Func_OpenProcessToken)(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle);
+typedef BOOL (WINAPI * Func_LookupPrivilegeValue)(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid);
+typedef BOOL (WINAPI * Func_AdjustTokenPrivileges)(HANDLE TokenHandle, BOOL DisableAllPrivileges,
+    PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength);
+}
+#define GET_PROC_ADDR(fff, name) Func_ ## fff  my_ ## fff  = (Func_ ## fff)GetProcAddress(hModule, name)
+#endif
+
+bool EnablePrivilege(LPCTSTR privilegeName, bool enable)
+{
+  bool res = false;
+
+  #ifndef _UNICODE
+
+  HMODULE hModule = ::LoadLibrary(TEXT("Advapi32.dll"));
+  if (hModule == NULL)
+    return false;
+  
+  GET_PROC_ADDR(OpenProcessToken, "OpenProcessToken");
+  GET_PROC_ADDR(LookupPrivilegeValue, "LookupPrivilegeValueA");
+  GET_PROC_ADDR(AdjustTokenPrivileges, "AdjustTokenPrivileges");
+  
+  if (my_OpenProcessToken &&
+      my_AdjustTokenPrivileges &&
+      my_LookupPrivilegeValue)
+  
+  #endif
+
+  {
+    HANDLE token;
+    if (MY_FUNC_SELECT(OpenProcessToken)(::GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &token))
+    {
+      TOKEN_PRIVILEGES tp;
+      if (MY_FUNC_SELECT(LookupPrivilegeValue)(NULL, privilegeName, &(tp.Privileges[0].Luid)))
+      {
+        tp.PrivilegeCount = 1;
+        tp.Privileges[0].Attributes = (enable ? SE_PRIVILEGE_ENABLED : 0);
+        if (MY_FUNC_SELECT(AdjustTokenPrivileges)(token, FALSE, &tp, 0, NULL, NULL))
+          res = (GetLastError() == ERROR_SUCCESS);
+      }
+      ::CloseHandle(token);
+    }
+  }
+    
+  #ifndef _UNICODE
+
+  ::FreeLibrary(hModule);
+  
+  #endif
+
+  return res;
+}
+
+
+
+typedef void (WINAPI * Func_RtlGetVersion) (OSVERSIONINFOEXW *);
+
+/*
+  We suppose that Window 10 works incorrectly with "Large Pages" at:
+    - Windows 10 1703 (15063)
+    - Windows 10 1709 (16299)
+
+    - Windows 10 1809 (17763) on some CPUs that have no 1 GB page support.
+         We need more information about that new BUG in Windows.
+*/
+
+unsigned Get_LargePages_RiskLevel()
+{
+  OSVERSIONINFOEXW vi;
+  HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
+  if (!ntdll)
+    return 0;
+  Func_RtlGetVersion func = (Func_RtlGetVersion)GetProcAddress(ntdll, "RtlGetVersion");
+  if (!func)
+    return 0;
+  func(&vi);
+  if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
+    return 0;
+  if (vi.dwMajorVersion + vi.dwMinorVersion != 10)
+    return 0;
+  if (vi.dwBuildNumber <= 16299)
+    return 1;
+
+  #ifdef MY_CPU_X86_OR_AMD64
+  if (!CPU_IsSupported_PageGB())
+    return 1;
+  #endif
+
+  return 0;
+}
+
+#endif
+
+}}

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

@@ -0,0 +1,40 @@
+// Windows/MemoryLock.h
+
+#ifndef __WINDOWS_MEMORY_LOCK_H
+#define __WINDOWS_MEMORY_LOCK_H
+
+#include "../Common/MyWindows.h"
+
+namespace NWindows {
+namespace NSecurity {
+
+#ifndef UNDER_CE
+
+bool EnablePrivilege(LPCTSTR privilegeName, bool enable = true);
+
+inline bool EnablePrivilege_LockMemory(bool enable = true)
+{
+  return EnablePrivilege(SE_LOCK_MEMORY_NAME, enable);
+}
+
+inline void EnablePrivilege_SymLink()
+{
+  /* Probably we do not to set any Privilege for junction points.
+     But we need them for Symbolic links */
+  NSecurity::EnablePrivilege(SE_RESTORE_NAME);
+  
+  /* Probably we need only SE_RESTORE_NAME, but there is also
+     SE_CREATE_SYMBOLIC_LINK_NAME. So we set it also. Do we need it? */
+
+  NSecurity::EnablePrivilege(TEXT("SeCreateSymbolicLinkPrivilege")); // SE_CREATE_SYMBOLIC_LINK_NAME
+  
+  // Do we need to set SE_BACKUP_NAME ?
+}
+
+unsigned Get_LargePages_RiskLevel();
+
+#endif
+
+}}
+
+#endif

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

@@ -0,0 +1,46 @@
+// Windows/NtCheck.h
+
+#ifndef __WINDOWS_NT_CHECK_H
+#define __WINDOWS_NT_CHECK_H
+
+#ifdef _WIN32
+
+#include "../Common/MyWindows.h"
+
+#if !defined(_WIN64) && !defined(UNDER_CE)
+static inline bool IsItWindowsNT()
+{
+  OSVERSIONINFO vi;
+  vi.dwOSVersionInfoSize = sizeof(vi);
+  return (::GetVersionEx(&vi) && vi.dwPlatformId == VER_PLATFORM_WIN32_NT);
+}
+#endif
+
+#ifndef _UNICODE
+  #if defined(_WIN64) || defined(UNDER_CE)
+    bool g_IsNT = true;
+    #define SET_IS_NT
+  #else
+    bool g_IsNT = false;
+    #define SET_IS_NT g_IsNT = IsItWindowsNT();
+  #endif
+  #define NT_CHECK_ACTION
+  // #define NT_CHECK_ACTION { NT_CHECK_FAIL_ACTION }
+#else
+  #if !defined(_WIN64) && !defined(UNDER_CE)
+    #define NT_CHECK_ACTION if (!IsItWindowsNT()) { NT_CHECK_FAIL_ACTION }
+  #else
+    #define NT_CHECK_ACTION
+  #endif
+  #define SET_IS_NT
+#endif
+
+#define NT_CHECK  NT_CHECK_ACTION SET_IS_NT
+
+#else
+
+#define NT_CHECK
+
+#endif
+
+#endif