react-native-update 10.34.2 → 10.34.3

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

@@ -0,0 +1,474 @@
+// Windows/Registry.cpp
+
+#include "StdAfx.h"
+
+#include <wchar.h>
+// #include <stdio.h>
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+#include "Registry.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NRegistry {
+
+#define MYASSERT(expr) // _ASSERTE(expr)
+#define MY_ASSUME(expr)
+
+/*
+static void Error()
+{
+  #ifdef _CONSOLE
+  printf("\nregistry error\n");
+  #else
+  MessageBoxW(0, L"registry error", L"", 0);
+  // exit(1);
+  #endif
+}
+
+#define MY_ASSUME(expr) { if (!(expr)) Error(); }
+*/
+
+LONG CKey::Create(HKEY parentKey, LPCTSTR keyName,
+    LPTSTR keyClass, DWORD options, REGSAM accessMask,
+    LPSECURITY_ATTRIBUTES securityAttributes, LPDWORD disposition) throw()
+{
+  MY_ASSUME(parentKey != NULL);
+  DWORD dispositionReal;
+  HKEY key = NULL;
+  LONG res = RegCreateKeyEx(parentKey, keyName, 0, keyClass,
+      options, accessMask, securityAttributes, &key, &dispositionReal);
+  if (disposition != NULL)
+    *disposition = dispositionReal;
+  if (res == ERROR_SUCCESS)
+  {
+    res = Close();
+    _object = key;
+  }
+  return res;
+}
+
+LONG CKey::Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask) throw()
+{
+  MY_ASSUME(parentKey != NULL);
+  HKEY key = NULL;
+  LONG res = RegOpenKeyEx(parentKey, keyName, 0, accessMask, &key);
+  if (res == ERROR_SUCCESS)
+  {
+    res = Close();
+    MYASSERT(res == ERROR_SUCCESS);
+    _object = key;
+  }
+  return res;
+}
+
+LONG CKey::Close() throw()
+{
+  LONG res = ERROR_SUCCESS;
+  if (_object != NULL)
+  {
+    res = RegCloseKey(_object);
+    _object = NULL;
+  }
+  return res;
+}
+
+// win95, win98: deletes subkey and all its subkeys
+// winNT to be deleted must not have subkeys
+LONG CKey::DeleteSubKey(LPCTSTR subKeyName) throw()
+{
+  MY_ASSUME(_object != NULL);
+  return RegDeleteKey(_object, subKeyName);
+}
+
+LONG CKey::RecurseDeleteKey(LPCTSTR subKeyName) throw()
+{
+  {
+    CKey key;
+    LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
+    if (res != ERROR_SUCCESS)
+      return res;
+    FILETIME fileTime;
+    const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
+    TCHAR buffer[kBufSize];
+    // we use loop limit here for some unexpected code failure
+    for (unsigned loop_cnt = 0; loop_cnt < (1u << 26); loop_cnt++)
+    {
+      DWORD size = kBufSize;
+      // we always request starting item (index==0) in each iteration,
+      // because we remove starting item (index==0) in each loop iteration.
+      res = RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime);
+      if (res != ERROR_SUCCESS)
+      {
+        // possible return codes:
+        //   ERROR_NO_MORE_ITEMS : are no more subkeys available
+        //   ERROR_MORE_DATA     : name buffer is too small
+        // we can try to remove (subKeyName), even if there is non ERROR_NO_MORE_ITEMS error.
+        // if (res != ERROR_NO_MORE_ITEMS) return res;
+        break;
+      }
+      res = key.RecurseDeleteKey(buffer);
+      if (res != ERROR_SUCCESS)
+        return res;
+    }
+    // key.Close();
+  }
+  return DeleteSubKey(subKeyName);
+}
+
+
+/////////////////////////
+// Value Functions
+
+static inline UInt32 BoolToUINT32(bool value) {  return (value ? 1: 0); }
+static inline bool UINT32ToBool(UInt32 value) {  return (value != 0); }
+
+
+LONG CKey::DeleteValue(LPCTSTR name) throw()
+{
+  MY_ASSUME(_object != NULL);
+  return ::RegDeleteValue(_object, name);
+}
+
+#ifndef _UNICODE
+LONG CKey::DeleteValue(LPCWSTR name)
+{
+  MY_ASSUME(_object != NULL);
+  if (g_IsNT)
+    return ::RegDeleteValueW(_object, name);
+  return DeleteValue(name == NULL ? NULL : (LPCSTR)GetSystemString(name));
+}
+#endif
+
+LONG CKey::SetValue(LPCTSTR name, UInt32 value) throw()
+{
+  MY_ASSUME(_object != NULL);
+  return RegSetValueEx(_object, name, 0, REG_DWORD,
+      (const BYTE *)&value, sizeof(UInt32));
+}
+
+LONG CKey::SetValue(LPCTSTR name, bool value) throw()
+{
+  return SetValue(name, BoolToUINT32(value));
+}
+
+
+// value must be string that is NULL terminated
+LONG CKey::SetValue(LPCTSTR name, LPCTSTR value) throw()
+{
+  MYASSERT(value != NULL);
+  MY_ASSUME(_object != NULL);
+  // note: RegSetValueEx supports (value == NULL), if (cbData == 0)
+  return RegSetValueEx(_object, name, 0, REG_SZ,
+      (const BYTE *)value, (DWORD)(((DWORD)lstrlen(value) + 1) * sizeof(TCHAR)));
+}
+
+/*
+LONG CKey::SetValue(LPCTSTR name, const CSysString &value)
+{
+  MYASSERT(value != NULL);
+  MY_ASSUME(_object != NULL);
+  return RegSetValueEx(_object, name, 0, REG_SZ,
+      (const BYTE *)(const TCHAR *)value, (value.Len() + 1) * sizeof(TCHAR));
+}
+*/
+
+#ifndef _UNICODE
+
+LONG CKey::SetValue(LPCWSTR name, LPCWSTR value)
+{
+  MYASSERT(value != NULL);
+  MY_ASSUME(_object != NULL);
+  if (g_IsNT)
+    return RegSetValueExW(_object, name, 0, REG_SZ,
+        (const BYTE *)value, (DWORD)(((DWORD)wcslen(value) + 1) * sizeof(wchar_t)));
+  return SetValue(name == NULL ? NULL :
+        (LPCSTR)GetSystemString(name),
+        (LPCSTR)GetSystemString(value));
+}
+
+#endif
+
+
+LONG CKey::SetValue(LPCTSTR name, const void *value, UInt32 size) throw()
+{
+  MYASSERT(value != NULL);
+  MY_ASSUME(_object != NULL);
+  return RegSetValueEx(_object, name, 0, REG_BINARY,
+      (const BYTE *)value, size);
+}
+
+LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value)
+{
+  MYASSERT(value != NULL);
+  CKey key;
+  LONG res = key.Create(parentKey, keyName);
+  if (res == ERROR_SUCCESS)
+    res = key.SetValue(valueName, value);
+  return res;
+}
+
+LONG CKey::SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw()
+{
+  MYASSERT(value != NULL);
+  CKey key;
+  LONG res = key.Create(_object, keyName);
+  if (res == ERROR_SUCCESS)
+    res = key.SetValue(valueName, value);
+  return res;
+}
+
+
+LONG CKey::GetValue_UInt32_IfOk(LPCTSTR name, UInt32 &value) throw()
+{
+  DWORD type = 0;
+  DWORD count = sizeof(value);
+  UInt32 value2; // = value;
+  const LONG res = QueryValueEx(name, &type, (LPBYTE)&value2, &count);
+  if (res == ERROR_SUCCESS)
+  {
+    // ERROR_UNSUPPORTED_TYPE
+    if (count != sizeof(value) || type != REG_DWORD)
+      return ERROR_UNSUPPORTED_TYPE; // ERROR_INVALID_DATA;
+    value = value2;
+  }
+  return res;
+}
+
+LONG CKey::GetValue_UInt64_IfOk(LPCTSTR name, UInt64 &value) throw()
+{
+  DWORD type = 0;
+  DWORD count = sizeof(value);
+  UInt64 value2; // = value;
+  const LONG res = QueryValueEx(name, &type, (LPBYTE)&value2, &count);
+  if (res == ERROR_SUCCESS)
+  {
+    if (count != sizeof(value) || type != REG_QWORD)
+      return ERROR_UNSUPPORTED_TYPE;
+    value = value2;
+  }
+  return res;
+}
+
+LONG CKey::GetValue_bool_IfOk(LPCTSTR name, bool &value) throw()
+{
+  UInt32 uintValue;
+  const LONG res = GetValue_UInt32_IfOk(name, uintValue);
+  if (res == ERROR_SUCCESS)
+    value = UINT32ToBool(uintValue);
+  return res;
+}
+
+
+
+LONG CKey::QueryValue(LPCTSTR name, CSysString &value)
+{
+  value.Empty();
+  LONG res = ERROR_SUCCESS;
+  {
+    // if we don't want multiple calls here,
+    // we can use big value (264) here.
+    // 3 is default available length in new string.
+    DWORD size_prev = 3 * sizeof(TCHAR);
+    // at least 2 attempts are required. But we use more attempts for cases,
+    // where string can be changed by anothner process
+    for (unsigned i = 0; i < 2 + 2; i++)
+    {
+      DWORD type = 0;
+      DWORD size = size_prev;
+      {
+        LPBYTE buf = (LPBYTE)value.GetBuf(size / sizeof(TCHAR));
+        res = QueryValueEx(name, &type, size == 0 ? NULL : buf, &size);
+        // if (size_prev == 0), then (res == ERROR_SUCCESS) is expected here, because we requested only size.
+      }
+      if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
+      {
+        if (type != REG_SZ && type != REG_EXPAND_SZ)
+        {
+          res = ERROR_UNSUPPORTED_TYPE;
+          size = 0;
+        }
+      }
+      else
+        size = 0;
+      if (size > size_prev)
+      {
+        size_prev = size;
+        size = 0;
+        res = ERROR_MORE_DATA;
+      }
+      value.ReleaseBuf_CalcLen(size / sizeof(TCHAR));
+      if (res != ERROR_MORE_DATA)
+        return res;
+    }
+  }
+  return res;
+}
+
+
+#ifndef _UNICODE
+
+LONG CKey::QueryValue(LPCWSTR name, UString &value)
+{
+  value.Empty();
+  LONG res = ERROR_SUCCESS;
+  if (g_IsNT)
+  {
+    DWORD size_prev = 3 * sizeof(wchar_t);
+    for (unsigned i = 0; i < 2 + 2; i++)
+    {
+      DWORD type = 0;
+      DWORD size = size_prev;
+      {
+        LPBYTE buf = (LPBYTE)value.GetBuf(size / sizeof(wchar_t));
+        res = RegQueryValueExW(_object, name, NULL, &type,
+            size == 0 ? NULL : buf, &size);
+      }
+      if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
+      {
+        if (type != REG_SZ && type != REG_EXPAND_SZ)
+        {
+          res = ERROR_UNSUPPORTED_TYPE;
+          size = 0;
+        }
+      }
+      else
+        size = 0;
+      if (size > size_prev)
+      {
+        size_prev = size;
+        size = 0;
+        res = ERROR_MORE_DATA;
+      }
+      value.ReleaseBuf_CalcLen(size / sizeof(wchar_t));
+      if (res != ERROR_MORE_DATA)
+        return res;
+    }
+  }
+  else
+  {
+    AString vTemp;
+    res = QueryValue(name == NULL ? NULL : (LPCSTR)GetSystemString(name), vTemp);
+    value = GetUnicodeString(vTemp);
+  }
+  return res;
+}
+
+#endif
+
+
+LONG CKey::QueryValue_Binary(LPCTSTR name, CByteBuffer &value)
+{
+  // value.Free();
+  DWORD size_prev = 0;
+  LONG res = ERROR_SUCCESS;
+  for (unsigned i = 0; i < 2 + 2; i++)
+  {
+    DWORD type = 0;
+    DWORD size = size_prev;
+    value.Alloc(size_prev);
+    res = QueryValueEx(name, &type, value.NonConstData(), &size);
+    // if (size_prev == 0), then (res == ERROR_SUCCESS) is expected here, because we requested only size.
+    if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
+    {
+      if (type != REG_BINARY)
+      {
+        res = ERROR_UNSUPPORTED_TYPE;
+        size = 0;
+      }
+    }
+    else
+      size = 0;
+    if (size > size_prev)
+    {
+      size_prev = size;
+      size = 0;
+      res = ERROR_MORE_DATA;
+    }
+    if (size < value.Size())
+      value.ChangeSize_KeepData(size, size);
+    if (res != ERROR_MORE_DATA)
+      return res;
+  }
+  return res;
+}
+
+
+LONG CKey::EnumKeys(CSysStringVector &keyNames)
+{
+  keyNames.Clear();
+  CSysString keyName;
+  for (DWORD index = 0; ; index++)
+  {
+    const unsigned kBufSize = MAX_PATH + 1; // 256 in ATL
+    FILETIME lastWriteTime;
+    DWORD nameSize = kBufSize;
+    const LONG res = ::RegEnumKeyEx(_object, index,
+        keyName.GetBuf(kBufSize), &nameSize,
+        NULL, NULL, NULL, &lastWriteTime);
+    keyName.ReleaseBuf_CalcLen(kBufSize);
+    if (res == ERROR_NO_MORE_ITEMS)
+      return ERROR_SUCCESS;
+    if (res != ERROR_SUCCESS)
+      return res;
+    keyNames.Add(keyName);
+  }
+}
+
+
+LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
+{
+  size_t numChars = 0;
+  unsigned i;
+  
+  for (i = 0; i < strings.Size(); i++)
+    numChars += strings[i].Len() + 1;
+  
+  CObjArray<wchar_t> buffer(numChars);
+  size_t pos = 0;
+  
+  for (i = 0; i < strings.Size(); i++)
+  {
+    const UString &s = strings[i];
+    const size_t size = s.Len() + 1;
+    wmemcpy(buffer + pos, s, size);
+    pos += size;
+  }
+  // if (pos != numChars) return E_FAIL;
+  return SetValue(valueName, buffer, (UInt32)numChars * sizeof(wchar_t));
+}
+
+LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
+{
+  strings.Clear();
+  CByteBuffer buffer;
+  const LONG res = QueryValue_Binary(valueName, buffer);
+  if (res != ERROR_SUCCESS)
+    return res;
+  const size_t dataSize = buffer.Size();
+  if (dataSize % sizeof(wchar_t))
+    return ERROR_INVALID_DATA;
+  const wchar_t *data = (const wchar_t *)(const void *)(const Byte  *)buffer;
+  const size_t numChars = dataSize / sizeof(wchar_t);
+  // we can check that all names are finished
+  // if (numChars != 0 && data[numChars - 1] != 0) return ERROR_INVALID_DATA;
+  size_t prev = 0;
+  UString s;
+  for (size_t i = 0; i < numChars; i++)
+  {
+    if (data[i] == 0)
+    {
+      s = data + prev;
+      strings.Add(s);
+      prev = i + 1;
+    }
+  }
+  return res;
+}
+
+}}

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

@@ -0,0 +1,96 @@
+// Windows/Registry.h
+
+#ifndef ZIP7_INC_WINDOWS_REGISTRY_H
+#define ZIP7_INC_WINDOWS_REGISTRY_H
+
+#include "../Common/MyBuffer.h"
+#include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NRegistry {
+
+LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value);
+
+class CKey
+{
+  HKEY _object;
+
+  LONG QueryValueEx(LPCTSTR lpValueName, LPDWORD lpType,
+      LPBYTE lpData, LPDWORD lpcbData)
+  {
+    return RegQueryValueEx(_object, lpValueName, NULL, lpType, lpData, lpcbData);
+  }
+
+public:
+  CKey(): _object(NULL) {}
+  ~CKey() { Close(); }
+
+  operator HKEY() const { return _object; }
+  void Attach(HKEY key) { _object = key; }
+  HKEY Detach()
+  {
+    const HKEY key = _object;
+    _object = NULL;
+    return key;
+  }
+
+  LONG Create(HKEY parentKey, LPCTSTR keyName,
+      LPTSTR keyClass = REG_NONE,
+      DWORD options = REG_OPTION_NON_VOLATILE,
+      REGSAM accessMask = KEY_ALL_ACCESS,
+      LPSECURITY_ATTRIBUTES securityAttributes = NULL,
+      LPDWORD disposition = NULL) throw();
+  LONG Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask = KEY_ALL_ACCESS) throw();
+
+  LONG Close() throw();
+
+  LONG DeleteSubKey(LPCTSTR subKeyName) throw();
+  LONG RecurseDeleteKey(LPCTSTR subKeyName) throw();
+
+  LONG DeleteValue(LPCTSTR name) throw();
+#ifndef _UNICODE
+  LONG DeleteValue(LPCWSTR name);
+#endif
+
+  LONG SetValue(LPCTSTR valueName, UInt32 value) throw();
+  LONG SetValue(LPCTSTR valueName, bool value) throw();
+  LONG SetValue(LPCTSTR valueName, LPCTSTR value) throw();
+  // LONG SetValue(LPCTSTR valueName, const CSysString &value);
+#ifndef _UNICODE
+  LONG SetValue(LPCWSTR name, LPCWSTR value);
+  // LONG SetValue(LPCWSTR name, const UString &value);
+#endif
+
+  LONG SetValue(LPCTSTR name, const void *value, UInt32 size) throw();
+
+  LONG SetValue_Strings(LPCTSTR valueName, const UStringVector &strings);
+  LONG GetValue_Strings(LPCTSTR valueName, UStringVector &strings);
+
+  LONG SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw();
+
+  // GetValue_[type]_IfOk():
+  //   if (return_result == ERROR_SUCCESS), (value) variable was read from registry
+  //   if (return_result != ERROR_SUCCESS), (value) variable was not changed
+  LONG GetValue_UInt32_IfOk(LPCTSTR name, UInt32 &value) throw();
+  LONG GetValue_UInt64_IfOk(LPCTSTR name, UInt64 &value) throw();
+  LONG GetValue_bool_IfOk(LPCTSTR name, bool &value) throw();
+
+  // QueryValue():
+  //   if (return_result == ERROR_SUCCESS), (value) string was read from registry
+  //   if (return_result != ERROR_SUCCESS), (value) string was cleared
+  LONG QueryValue(LPCTSTR name, CSysString &value);
+#ifndef _UNICODE
+  LONG QueryValue(LPCWSTR name, UString &value);
+#endif
+
+  // QueryValue_Binary():
+  //   if (return_result == ERROR_SUCCESS), (value) buffer was read from registry (BINARY data)
+  //   if (return_result != ERROR_SUCCESS), (value) buffer was cleared
+  LONG QueryValue_Binary(LPCTSTR name, CByteBuffer &value);
+
+  LONG EnumKeys(CSysStringVector &keyNames);
+};
+
+}}
+
+#endif

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

@@ -0,0 +1,103 @@
+// Windows/ResourceString.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "ResourceString.h"
+
+extern HINSTANCE g_hInstance;
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+
+#ifndef _UNICODE
+
+static CSysString MyLoadStringA(HINSTANCE hInstance, UINT resourceID)
+{
+  CSysString s;
+  int size = 128;
+  int len;
+  do
+  {
+    size <<= 1;
+    len = ::LoadString(hInstance, resourceID, s.GetBuf((unsigned)size - 1), size);
+  }
+  while (size - len <= 1);
+  s.ReleaseBuf_CalcLen((unsigned)len);
+  return s;
+}
+
+#endif
+
+static const int kStartSize = 256;
+
+static void MyLoadString2(HINSTANCE hInstance, UINT resourceID, UString &s)
+{
+  int size = kStartSize;
+  int len;
+  do
+  {
+    size <<= 1;
+    len = ::LoadStringW(hInstance, resourceID, s.GetBuf((unsigned)size - 1), size);
+  }
+  while (size - len <= 1);
+  s.ReleaseBuf_CalcLen((unsigned)len);
+}
+
+// NT4 doesn't support LoadStringW(,,, 0) to get pointer to resource string. So we don't use it.
+
+UString MyLoadString(UINT resourceID)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+    return GetUnicodeString(MyLoadStringA(g_hInstance, resourceID));
+  else
+  #endif
+  {
+    {
+      wchar_t s[kStartSize];
+      s[0] = 0;
+      int len = ::LoadStringW(g_hInstance, resourceID, s, kStartSize);
+      if (kStartSize - len > 1)
+        return s;
+    }
+    UString dest;
+    MyLoadString2(g_hInstance, resourceID, dest);
+    return dest;
+  }
+}
+
+void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest)
+{
+  dest.Empty();
+  #ifndef _UNICODE
+  if (!g_IsNT)
+    MultiByteToUnicodeString2(dest, MyLoadStringA(hInstance, resourceID));
+  else
+  #endif
+  {
+    {
+      wchar_t s[kStartSize];
+      s[0] = 0;
+      int len = ::LoadStringW(hInstance, resourceID, s, kStartSize);
+      if (kStartSize - len > 1)
+      {
+        dest = s;
+        return;
+      }
+    }
+    MyLoadString2(hInstance, resourceID, dest);
+  }
+}
+
+void MyLoadString(UINT resourceID, UString &dest)
+{
+  MyLoadString(g_hInstance, resourceID, dest);
+}
+
+}

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

@@ -0,0 +1,17 @@
+// Windows/ResourceString.h
+
+#ifndef ZIP7_INC_WINDOWS_RESOURCE_STRING_H
+#define ZIP7_INC_WINDOWS_RESOURCE_STRING_H
+
+#include "../Common/MyString.h"
+#include "../Common/MyWindows.h"
+
+namespace NWindows {
+
+UString MyLoadString(UINT resourceID);
+void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest);
+void MyLoadString(UINT resourceID, UString &dest);
+
+}
+
+#endif