react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Crypto/MyAes.cpp

@@ -10,268 +10,103 @@ namespace NCrypto {
 
 static struct CAesTabInit { CAesTabInit() { AesGenTables();} } g_AesTabInit;
 
-CAesCoder::CAesCoder(
-      // bool encodeMode,
-      unsigned keySize
-      // , bool ctrMode
-      ):
-  _keyIsSet(false),
-  // _encodeMode(encodeMode),
-  // _ctrMode(ctrMode),
+CAesCbcCoder::CAesCbcCoder(bool encodeMode, unsigned keySize):
   _keySize(keySize),
-  // _ctrPos(0), // _ctrPos =0 will be set in Init()
-  _aes(AES_NUM_IVMRK_WORDS * 4 + AES_BLOCK_SIZE * 2)
+  _keyIsSet(false),
+  _encodeMode(encodeMode)
 {
-  // _offset = ((0 - (unsigned)(ptrdiff_t)_aes) & 0xF) / sizeof(UInt32);
+  _offset = ((0 - (unsigned)(ptrdiff_t)_aes) & 0xF) / sizeof(UInt32);
   memset(_iv, 0, AES_BLOCK_SIZE);
-  /*
-  // we can use the following code to test 32-bit overflow case for AES-CTR
-  for (unsigned i = 0; i < 16; i++) _iv[i] = (Byte)(i + 1);
-  _iv[0] = 0xFE; _iv[1] = _iv[2] = _iv[3] = 0xFF;
-  */
+  SetFunctions(0);
 }
 
-Z7_COM7F_IMF(CAesCoder::Init())
+STDMETHODIMP CAesCbcCoder::Init()
 {
-  _ctrPos = 0;
-  AesCbc_Init(Aes(), _iv);
-  return _keyIsSet ? S_OK : E_NOTIMPL; // E_FAIL
+  AesCbc_Init(_aes + _offset, _iv);
+  return _keyIsSet ? S_OK : E_FAIL;
 }
 
-Z7_COM7F_IMF2(UInt32, CAesCoder::Filter(Byte *data, UInt32 size))
+STDMETHODIMP_(UInt32) CAesCbcCoder::Filter(Byte *data, UInt32 size)
 {
   if (!_keyIsSet)
     return 0;
+  if (size == 0)
+    return 0;
   if (size < AES_BLOCK_SIZE)
-  {
-    if (size == 0)
-      return 0;
     return AES_BLOCK_SIZE;
-  }
   size >>= 4;
-  // (data) must be aligned for 16-bytes here
-  _codeFunc(Aes(), data, size);
+  _codeFunc(_aes + _offset, data, size);
   return size << 4;
 }
 
-
-Z7_COM7F_IMF(CAesCoder::SetKey(const Byte *data, UInt32 size))
+STDMETHODIMP CAesCbcCoder::SetKey(const Byte *data, UInt32 size)
 {
   if ((size & 0x7) != 0 || size < 16 || size > 32)
     return E_INVALIDARG;
   if (_keySize != 0 && size != _keySize)
     return E_INVALIDARG;
-  _setKeyFunc(Aes() + 4, data, size);
+  AES_SET_KEY_FUNC setKeyFunc = _encodeMode ? Aes_SetKey_Enc : Aes_SetKey_Dec;
+  setKeyFunc(_aes + _offset + 4, data, size);
   _keyIsSet = true;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CAesCoder::SetInitVector(const Byte *data, UInt32 size))
+STDMETHODIMP CAesCbcCoder::SetInitVector(const Byte *data, UInt32 size)
 {
   if (size != AES_BLOCK_SIZE)
     return E_INVALIDARG;
   memcpy(_iv, data, size);
-  /* we allow SetInitVector() call before SetKey() call.
-     so we ignore possible error in Init() here */
-  CAesCoder::Init(); // don't call virtual function here !!!
+  CAesCbcCoder::Init(); // don't call virtual function here !!!
   return S_OK;
 }
 
+EXTERN_C_BEGIN
 
-#ifndef Z7_SFX
+void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);
 
-/*
-Z7_COM7F_IMF(CAesCtrCoder::Init())
-{
-  _ctrPos = 0;
-  return CAesCoder::Init();
-}
-*/
+void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
+
+EXTERN_C_END
 
-Z7_COM7F_IMF2(UInt32, CAesCtrCoder::Filter(Byte *data, UInt32 size))
+bool CAesCbcCoder::SetFunctions(UInt32 algo)
 {
-  if (!_keyIsSet)
-    return 0;
-  if (size == 0)
-    return 0;
-  
-  if (_ctrPos != 0)
+  _codeFunc = _encodeMode ?
+      g_AesCbc_Encode :
+      g_AesCbc_Decode;
+  if (algo == 1)
   {
-    /* Optimized caller will not call here */
-    const Byte *ctr = (Byte *)(Aes() + AES_NUM_IVMRK_WORDS);
-    unsigned num = 0;
-    for (unsigned i = _ctrPos; i != AES_BLOCK_SIZE; i++)
-    {
-      if (num == size)
-      {
-        _ctrPos = i;
-        return num;
-      }
-      data[num++] ^= ctr[i];
-    }
-    _ctrPos = 0;
-    /* if (num < size) {
-       we can filter more data with _codeFunc().
-       But it's supposed that the caller can work correctly,
-       even if we do only partial filtering here.
-       So we filter data only for current 16-byte block. }
-    */
-    /*
-    size -= num;
-    size >>= 4;
-    // (data) must be aligned for 16-bytes here
-    _codeFunc(Aes(), data + num, size);
-    return num + (size << 4);
-    */
-    return num;
+    _codeFunc = _encodeMode ?
+        AesCbc_Encode:
+        AesCbc_Decode;
   }
-  
-  if (size < AES_BLOCK_SIZE)
+  if (algo == 2)
   {
-    /* The good optimized caller can call here only in last Filter() call.
-       But we support also non-optimized callers,
-       where another Filter() calls are allowed after this call.
-    */
-    Byte *ctr = (Byte *)(Aes() + AES_NUM_IVMRK_WORDS);
-    memset(ctr, 0, AES_BLOCK_SIZE);
-    memcpy(ctr, data, size);
-    _codeFunc(Aes(), ctr, 1);
-    memcpy(data, ctr, size);
-    _ctrPos = size;
-    return size;
+    #ifdef MY_CPU_X86_OR_AMD64
+    if (g_AesCbc_Encode != AesCbc_Encode_Intel)
+    #endif
+      return false;
   }
-  
-  size >>= 4;
-  // (data) must be aligned for 16-bytes here
-  _codeFunc(Aes(), data, size);
-  return size << 4;
+  return true;
 }
 
-#endif // Z7_SFX
-
-
-#ifndef Z7_EXTRACT_ONLY
-
-#ifdef MY_CPU_X86_OR_AMD64
-
-  #if defined(__INTEL_COMPILER)
-    #if (__INTEL_COMPILER >= 1110)
-      #define USE_HW_AES
-      #if (__INTEL_COMPILER >= 1900)
-        #define USE_HW_VAES
-      #endif
-    #endif
-  #elif defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30800) \
-     || defined(Z7_GCC_VERSION)   && (Z7_GCC_VERSION   >= 40400)
-    #define USE_HW_AES
-      #if defined(__clang__) && (__clang_major__ >= 8) \
-          || defined(__GNUC__) && (__GNUC__ >= 8)
-        #define USE_HW_VAES
-      #endif
-  #elif defined(_MSC_VER)
-    #define USE_HW_AES
-    #define USE_HW_VAES
-  #endif
-
-#elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
-  
-  #if   defined(__ARM_FEATURE_AES) \
-     || defined(__ARM_FEATURE_CRYPTO)
-    #define USE_HW_AES
-  #else
-    #if  defined(MY_CPU_ARM64) \
-      || defined(__ARM_ARCH) && (__ARM_ARCH >= 4) \
-      || defined(Z7_MSC_VER_ORIGINAL)
-    #if  defined(__ARM_FP) && \
-          (   defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30800) \
-           || defined(__GNUC__) && (__GNUC__ >= 6) \
-          ) \
-      || defined(Z7_MSC_VER_ORIGINAL) && (_MSC_VER >= 1910)
-    #if  defined(MY_CPU_ARM64) \
-      || !defined(Z7_CLANG_VERSION) \
-      || defined(__ARM_NEON) && \
-          (Z7_CLANG_VERSION < 170000 || \
-           Z7_CLANG_VERSION > 170001)
-      #define USE_HW_AES
-    #endif
-    #endif
-    #endif
-  #endif
-#endif
-
-#ifdef USE_HW_AES
-// #pragma message("=== MyAES.c USE_HW_AES === ")
-
-    #define SET_AES_FUNC_2(f2) \
-      if (algo == 2) if (g_Aes_SupportedFunctions_Flags & k_Aes_SupportedFunctions_HW) \
-      { f = f2; }
-  #ifdef USE_HW_VAES
-    #define SET_AES_FUNC_23(f2, f3) \
-      SET_AES_FUNC_2(f2) \
-      if (algo == 3) if (g_Aes_SupportedFunctions_Flags & k_Aes_SupportedFunctions_HW_256) \
-      { f = f3; }
-  #else  // USE_HW_VAES
-    #define SET_AES_FUNC_23(f2, f3) \
-      SET_AES_FUNC_2(f2)
-  #endif // USE_HW_VAES
-#else  // USE_HW_AES
-    #define SET_AES_FUNC_23(f2, f3)
-#endif // USE_HW_AES
-
-#define SET_AES_FUNCS(c, f0, f1, f2, f3) \
-  bool c::SetFunctions(UInt32 algo) { \
-  _codeFunc = f0; if (algo < 1) return true; \
-  AES_CODE_FUNC f = NULL; \
-  if (algo == 1) { f = f1; } \
-  SET_AES_FUNC_23(f2, f3) \
-  if (f) { _codeFunc = f; return true; } \
-  return false; }
-
-
-
-#ifndef Z7_SFX
-SET_AES_FUNCS(
-    CAesCtrCoder,
-  g_AesCtr_Code,
-    AesCtr_Code,
-    AesCtr_Code_HW,
-    AesCtr_Code_HW_256)
-#endif
-
-SET_AES_FUNCS(
-    CAesCbcEncoder,
-  g_AesCbc_Encode,
-    AesCbc_Encode,
-    AesCbc_Encode_HW,
-    AesCbc_Encode_HW)
-
-SET_AES_FUNCS(
-    CAesCbcDecoder,
-  g_AesCbc_Decode,
-    AesCbc_Decode,
-    AesCbc_Decode_HW,
-    AesCbc_Decode_HW_256)
-
-Z7_COM7F_IMF(CAesCoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+STDMETHODIMP CAesCbcCoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
 {
-  UInt32 algo = 0;
   for (UInt32 i = 0; i < numProps; i++)
   {
+    const PROPVARIANT &prop = coderProps[i];
     if (propIDs[i] == NCoderPropID::kDefaultProp)
     {
-      const PROPVARIANT &prop = coderProps[i];
       if (prop.vt != VT_UI4)
         return E_INVALIDARG;
-      if (prop.ulVal > 3)
+      if (!SetFunctions(prop.ulVal))
         return E_NOTIMPL;
-      algo = prop.ulVal;
     }
   }
-  if (!SetFunctions(algo))
-    return E_NOTIMPL;
   return S_OK;
 }
 
-#endif // Z7_EXTRACT_ONLY
-
 }

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Crypto/MyAes.h

@@ -1,121 +1,56 @@
 // Crypto/MyAes.h
 
-#ifndef ZIP7_INC_CRYPTO_MY_AES_H
-#define ZIP7_INC_CRYPTO_MY_AES_H
+#ifndef __CRYPTO_MY_AES_H
+#define __CRYPTO_MY_AES_H
 
 #include "../../../C/Aes.h"
 
-#include "../../Common/MyBuffer2.h"
 #include "../../Common/MyCom.h"
 
 #include "../ICoder.h"
 
 namespace NCrypto {
 
-#ifdef Z7_EXTRACT_ONLY
-#define Z7_IFACEN_IAesCoderSetFunctions(x)
-#else
-#define Z7_IFACEN_IAesCoderSetFunctions(x) \
-  virtual bool SetFunctions(UInt32 algo) x
-#endif
-
-
-class CAesCoder:
+class CAesCbcCoder:
   public ICompressFilter,
   public ICryptoProperties,
- #ifndef Z7_EXTRACT_ONLY
   public ICompressSetCoderProperties,
- #endif
   public CMyUnknownImp
 {
-  Z7_COM_QI_BEGIN2(ICompressFilter)
-  Z7_COM_QI_ENTRY(ICryptoProperties)
- #ifndef Z7_EXTRACT_ONLY
-  Z7_COM_QI_ENTRY(ICompressSetCoderProperties)
- #endif
-  Z7_COM_QI_END
-  Z7_COM_ADDREF_RELEASE
-  
-public:
-  Z7_IFACE_COM7_IMP_NONFINAL(ICompressFilter)
-  Z7_IFACE_COM7_IMP(ICryptoProperties)
-private:
- #ifndef Z7_EXTRACT_ONLY
-  Z7_IFACE_COM7_IMP(ICompressSetCoderProperties)
- #endif
-
-protected:
-  bool _keyIsSet;
-  // bool _encodeMode;
-  // bool _ctrMode;
-  // unsigned _offset;
-  unsigned _keySize;
-  unsigned _ctrPos; // we need _ctrPos here for Init() / SetInitVector()
   AES_CODE_FUNC _codeFunc;
-  AES_SET_KEY_FUNC _setKeyFunc;
-private:
-  // UInt32 _aes[AES_NUM_IVMRK_WORDS + 3];
-  CAlignedBuffer1 _aes;
-
+  unsigned _offset;
+  unsigned _keySize;
+  bool _keyIsSet;
+  bool _encodeMode;
+  UInt32 _aes[AES_NUM_IVMRK_WORDS + 3];
   Byte _iv[AES_BLOCK_SIZE];
 
-  // UInt32 *Aes() { return _aes + _offset; }
-protected:
-  UInt32 *Aes() { return (UInt32 *)(void *)(Byte *)_aes; }
-
- Z7_IFACE_PURE(IAesCoderSetFunctions)
+  bool SetFunctions(UInt32 algo);
 
 public:
-  CAesCoder(
-      // bool encodeMode,
-      unsigned keySize
-      // , bool ctrMode
-      );
-  virtual ~CAesCoder() {}   // we need virtual destructor for derived classes
-  void SetKeySize(unsigned size) { _keySize = size; }
-};
-
-
-#ifndef Z7_EXTRACT_ONLY
-struct CAesCbcEncoder: public CAesCoder
-{
-  CAesCbcEncoder(unsigned keySize = 0): CAesCoder(keySize)
-  {
-    _setKeyFunc = Aes_SetKey_Enc;
-    _codeFunc = g_AesCbc_Encode;
-  }
-  Z7_IFACE_IMP(IAesCoderSetFunctions)
+  CAesCbcCoder(bool encodeMode, unsigned keySize);
+  
+  virtual ~CAesCbcCoder() {};   // we need virtual destructor for derived classes
+  
+  MY_UNKNOWN_IMP3(ICompressFilter, ICryptoProperties, ICompressSetCoderProperties)
+  
+  INTERFACE_ICompressFilter(;)
+  
+  STDMETHOD(SetKey)(const Byte *data, UInt32 size);
+  STDMETHOD(SetInitVector)(const Byte *data, UInt32 size);
+  
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
 };
-#endif
 
-struct CAesCbcDecoder: public CAesCoder
+struct CAesCbcEncoder: public CAesCbcCoder
 {
-  CAesCbcDecoder(unsigned keySize = 0): CAesCoder(keySize)
-  {
-    _setKeyFunc = Aes_SetKey_Dec;
-    _codeFunc = g_AesCbc_Decode;
-  }
-  Z7_IFACE_IMP(IAesCoderSetFunctions)
+  CAesCbcEncoder(unsigned keySize = 0): CAesCbcCoder(true, keySize) {}
 };
 
-#ifndef Z7_SFX
-struct CAesCtrCoder: public CAesCoder
+struct CAesCbcDecoder: public CAesCbcCoder
 {
-private:
-  // unsigned _ctrPos;
-  // Z7_IFACE_COM7_IMP(ICompressFilter)
-  // Z7_COM7F_IMP(Init())
-  Z7_COM7F_IMP2(UInt32, Filter(Byte *data, UInt32 size))
-public:
-  CAesCtrCoder(unsigned keySize = 0): CAesCoder(keySize)
-  {
-    _ctrPos = 0;
-    _setKeyFunc = Aes_SetKey_Enc;
-    _codeFunc = g_AesCtr_Code;
-  }
-  Z7_IFACE_IMP(IAesCoderSetFunctions)
+  CAesCbcDecoder(unsigned keySize = 0): CAesCbcCoder(false, keySize) {}
 };
-#endif
 
 }
 

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Crypto/MyAesReg.cpp

@@ -8,22 +8,9 @@
 
 namespace NCrypto {
 
-#ifndef Z7_SFX
-
-#define REGISTER_AES_2(name, nameString, keySize) \
-  REGISTER_FILTER_E(name, \
-    CAesCbcDecoder(keySize), \
-    CAesCbcEncoder(keySize), \
-    0x6F00100 | ((keySize - 16) * 8) | (/* isCtr */ 0 ? 4 : 1), \
-    nameString) \
-
-#define REGISTER_AES(name, nameString) \
-  /* REGISTER_AES_2(AES128 ## name, "AES128" nameString, 16) */ \
-  /* REGISTER_AES_2(AES192 ## name, "AES192" nameString, 24) */ \
-  REGISTER_AES_2(AES256 ## name, "AES256" nameString, 32) \
-
-REGISTER_AES(CBC, "CBC")
-
-#endif
+REGISTER_FILTER_E(AES256CBC,
+    CAesCbcDecoder(32),
+    CAesCbcEncoder(32),
+    0x6F00181, "AES256CBC")
 
 }

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Crypto/RandGen.cpp

@@ -6,7 +6,7 @@
 
 #ifndef USE_STATIC_SYSTEM_RAND
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 #include "../../Windows/Synchronization.h"
 #endif
 
@@ -19,7 +19,7 @@
 
 #ifdef USE_STATIC_RtlGenRandom
 
-// #include <NTSecAPI.h>
+#include <ntsecapi.h>
 
 EXTERN_C_BEGIN
 #ifndef RtlGenRandom
@@ -59,7 +59,6 @@ EXTERN_C_END
 
 void CRandomGenerator::Init()
 {
-  MY_ALIGN (16)
   CSha256 hash;
   Sha256_Init(&hash);
 
@@ -69,16 +68,15 @@ void CRandomGenerator::Init()
   #ifndef UNDER_CE
   const unsigned kNumIterations_Small = 100;
   const unsigned kBufSize = 32;
-  MY_ALIGN (16)
   Byte buf[kBufSize];
   #endif
 
   #ifdef _WIN32
 
   DWORD w = ::GetCurrentProcessId();
-  HASH_UPD(w)
+  HASH_UPD(w);
   w = ::GetCurrentThreadId();
-  HASH_UPD(w)
+  HASH_UPD(w);
 
   #ifdef UNDER_CE
   /*
@@ -96,14 +94,11 @@ void CRandomGenerator::Init()
   }
   #else
   {
-    const HMODULE hModule = ::LoadLibrary(TEXT("advapi32.dll"));
+    HMODULE hModule = ::LoadLibrary(TEXT("Advapi32.dll"));
     if (hModule)
     {
       // SystemFunction036() is real name of RtlGenRandom() function
-      const
-      Func_RtlGenRandom
-        my_RtlGenRandom = Z7_GET_PROC_ADDRESS(
-      Func_RtlGenRandom, hModule, "SystemFunction036");
+      Func_RtlGenRandom my_RtlGenRandom = (Func_RtlGenRandom)GetProcAddress(hModule, "SystemFunction036");
       if (my_RtlGenRandom)
       {
         if (my_RtlGenRandom(buf, kBufSize))
@@ -120,9 +115,9 @@ void CRandomGenerator::Init()
   #else
   
   pid_t pid = getpid();
-  HASH_UPD(pid)
+  HASH_UPD(pid);
   pid = getppid();
-  HASH_UPD(pid)
+  HASH_UPD(pid);
 
   {
     int f = open("/dev/urandom", O_RDONLY);
@@ -131,11 +126,11 @@ void CRandomGenerator::Init()
     {
       do
       {
-        ssize_t n = read(f, buf, numBytes);
+        int n = read(f, buf, numBytes);
         if (n <= 0)
           break;
-        Sha256_Update(&hash, buf, (size_t)n);
-        numBytes -= (unsigned)n;
+        Sha256_Update(&hash, buf, n);
+        numBytes -= n;
       }
       while (numBytes);
       close(f);
@@ -167,25 +162,25 @@ void CRandomGenerator::Init()
     #ifdef _WIN32
     LARGE_INTEGER v;
     if (::QueryPerformanceCounter(&v))
-      HASH_UPD(v.QuadPart)
+      HASH_UPD(v.QuadPart);
     #endif
 
     #ifdef USE_POSIX_TIME
     #ifdef USE_POSIX_TIME2
     timeval v;
-    if (gettimeofday(&v, NULL) == 0)
+    if (gettimeofday(&v, 0) == 0)
     {
-      HASH_UPD(v.tv_sec)
-      HASH_UPD(v.tv_usec)
+      HASH_UPD(v.tv_sec);
+      HASH_UPD(v.tv_usec);
     }
     #endif
-    const time_t v2 = time(NULL);
-    HASH_UPD(v2)
+    time_t v2 = time(NULL);
+    HASH_UPD(v2);
     #endif
 
     #ifdef _WIN32
-    const DWORD tickCount = ::GetTickCount();
-    HASH_UPD(tickCount)
+    DWORD tickCount = ::GetTickCount();
+    HASH_UPD(tickCount);
     #endif
     
     for (unsigned j = 0; j < 100; j++)
@@ -201,7 +196,7 @@ void CRandomGenerator::Init()
   _needInit = false;
 }
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
   static NWindows::NSynchronization::CCriticalSection g_CriticalSection;
   #define MT_LOCK NWindows::NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
 #else
@@ -216,7 +211,6 @@ void CRandomGenerator::Generate(Byte *data, unsigned size)
     Init();
   while (size != 0)
   {
-    MY_ALIGN (16)
     CSha256 hash;
     
     Sha256_Init(&hash);
@@ -225,9 +219,8 @@ void CRandomGenerator::Generate(Byte *data, unsigned size)
     
     Sha256_Init(&hash);
     UInt32 salt = 0xF672ABD1;
-    HASH_UPD(salt)
+    HASH_UPD(salt);
     Sha256_Update(&hash, _buff, SHA256_DIGEST_SIZE);
-    MY_ALIGN (16)
     Byte buff[SHA256_DIGEST_SIZE];
     Sha256_Final(&hash, buff);
     for (unsigned i = 0; i < SHA256_DIGEST_SIZE && size != 0; i++, size--)
@@ -235,7 +228,6 @@ void CRandomGenerator::Generate(Byte *data, unsigned size)
   }
 }
 
-MY_ALIGN (16)
 CRandomGenerator g_RandomGenerator;
 
 #endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Crypto/RandGen.h

@@ -1,7 +1,7 @@
 // RandGen.h
 
-#ifndef ZIP7_INC_CRYPTO_RAND_GEN_H
-#define ZIP7_INC_CRYPTO_RAND_GEN_H
+#ifndef __CRYPTO_RAND_GEN_H
+#define __CRYPTO_RAND_GEN_H
 
 #include "../../../C/Sha256.h"
 
@@ -27,11 +27,10 @@ class CRandomGenerator
 
   void Init();
 public:
-  CRandomGenerator(): _needInit(true) {}
+  CRandomGenerator(): _needInit(true) {};
   void Generate(Byte *data, unsigned size);
 };
 
-MY_ALIGN (16)
 extern CRandomGenerator g_RandomGenerator;
 
 #define MY_RAND_GEN(data, size) g_RandomGenerator.Generate(data, size)

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Crypto/StdAfx.h

@@ -1,11 +1,8 @@
 // StdAfx.h
 
-#ifndef ZIP7_INC_STDAFX_H
-#define ZIP7_INC_STDAFX_H
+#ifndef __STDAFX_H
+#define __STDAFX_H
 
-#if defined(_MSC_VER) && _MSC_VER >= 1800
-#pragma warning(disable : 4464) // relative include path contains '..'
-#endif
 #include "../../Common/Common.h"
 
 #endif