react-native-update 10.34.1 → 10.34.3

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

@@ -0,0 +1,210 @@
+// IStream.h
+
+#ifndef ZIP7_INC_ISTREAM_H
+#define ZIP7_INC_ISTREAM_H
+
+#include "../Common/Common0.h"
+#include "../Common/MyTypes.h"
+#include "../Common/MyWindows.h"
+
+#include "IDecl.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACE_CONSTR_STREAM_SUB(i, base, n) \
+  Z7_DECL_IFACE_7ZIP_SUB(i, base, 3, n) \
+  { Z7_IFACE_COM7_PURE(i) };
+
+#define Z7_IFACE_CONSTR_STREAM(i, n) \
+        Z7_IFACE_CONSTR_STREAM_SUB(i, IUnknown, n)
+
+
+/*
+ISequentialInStream::Read()
+  The requirement for caller: (processedSize != NULL).
+  The callee can allow (processedSize == NULL) for compatibility reasons.
+
+  if (size == 0), this function returns S_OK and (*processedSize) is set to 0.
+
+  if (size != 0)
+  {
+    Partial read is allowed: (*processedSize <= avail_size && *processedSize <= size),
+      where (avail_size) is the size of remaining bytes in stream.
+    If (avail_size != 0), this function must read at least 1 byte: (*processedSize > 0).
+    You must call Read() in loop, if you need to read exact amount of data.
+  }
+
+  If seek pointer before Read() call was changed to position past the end of stream:
+    if (seek_pointer >= stream_size), this function returns S_OK and (*processedSize) is set to 0.
+
+  ERROR CASES:
+    If the function returns error code, then (*processedSize) is size of
+    data written to (data) buffer (it can be data before error or data with errors).
+    The recommended way for callee to work with reading errors:
+      1) write part of data before error to (data) buffer and return S_OK.
+      2) return error code for further calls of Read().
+*/
+#define Z7_IFACEM_ISequentialInStream(x) \
+  x(Read(void *data, UInt32 size, UInt32 *processedSize))
+Z7_IFACE_CONSTR_STREAM(ISequentialInStream, 0x01)
+
+
+/*
+ISequentialOutStream::Write()
+  The requirement for caller: (processedSize != NULL).
+  The callee can allow (processedSize == NULL) for compatibility reasons.
+
+  if (size != 0)
+  {
+    Partial write is allowed: (*processedSize <= size),
+    but this function must write at least 1 byte: (*processedSize > 0).
+    You must call Write() in loop, if you need to write exact amount of data.
+  }
+
+  ERROR CASES:
+    If the function returns error code, then (*processedSize) is size of
+    data written from (data) buffer.
+*/
+#define Z7_IFACEM_ISequentialOutStream(x) \
+  x(Write(const void *data, UInt32 size, UInt32 *processedSize))
+Z7_IFACE_CONSTR_STREAM(ISequentialOutStream, 0x02)
+
+
+#ifdef _WIN32
+
+#ifdef __HRESULT_FROM_WIN32
+#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK __HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK)
+#else
+#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK   HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK)
+#endif
+
+#else
+
+#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK   MY_E_ERROR_NEGATIVE_SEEK
+
+#endif
+
+
+/*
+IInStream::Seek() / IOutStream::Seek()
+  If you seek to position before the beginning of the stream,
+  Seek() function returns error code:
+      Recommended error code is __HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK).
+      or STG_E_INVALIDFUNCTION
+  It is allowed to seek past the end of the stream.
+  if Seek() returns error, then the value of *newPosition is undefined.
+*/
+
+#define Z7_IFACEM_IInStream(x) \
+  x(Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+Z7_IFACE_CONSTR_STREAM_SUB(IInStream, ISequentialInStream, 0x03)
+
+#define Z7_IFACEM_IOutStream(x) \
+  x(Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)) \
+  x(SetSize(UInt64 newSize))
+Z7_IFACE_CONSTR_STREAM_SUB(IOutStream, ISequentialOutStream, 0x04)
+
+#define Z7_IFACEM_IStreamGetSize(x) \
+  x(GetSize(UInt64 *size))
+Z7_IFACE_CONSTR_STREAM(IStreamGetSize, 0x06)
+
+#define Z7_IFACEM_IOutStreamFinish(x) \
+  x(OutStreamFinish())
+Z7_IFACE_CONSTR_STREAM(IOutStreamFinish, 0x07)
+
+#define Z7_IFACEM_IStreamGetProps(x) \
+  x(GetProps(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib))
+Z7_IFACE_CONSTR_STREAM(IStreamGetProps, 0x08)
+
+
+struct CStreamFileProps
+{
+  UInt64 Size;
+  UInt64 VolID;
+  UInt64 FileID_Low;
+  UInt64 FileID_High;
+  UInt32 NumLinks;
+  UInt32 Attrib;
+  FILETIME CTime;
+  FILETIME ATime;
+  FILETIME MTime;
+};
+
+
+#define Z7_IFACEM_IStreamGetProps2(x) \
+  x(GetProps2(CStreamFileProps *props))
+Z7_IFACE_CONSTR_STREAM(IStreamGetProps2, 0x09)
+
+#define Z7_IFACEM_IStreamGetProp(x) \
+  x(GetProperty(PROPID propID, PROPVARIANT *value)) \
+  x(ReloadProps())
+Z7_IFACE_CONSTR_STREAM(IStreamGetProp, 0x0a)
+
+
+/*
+IStreamSetRestriction::SetRestriction(UInt64 begin, UInt64 end)
+  
+  It sets region of data in output stream that is restricted.
+  For restricted region it's expected (or allowed)
+  that the caller can write to same region with different calls of Write()/SetSize().
+  Another regions of output stream will be supposed as non-restricted:
+    - The callee usually doesn't flush the data in restricted region.
+    - The callee usually can flush data from non-restricted region after writing.
+
+Actual restiction rules depend also from current stream position.
+It's recommended to call SetRestriction() just before the Write() call.
+So the callee can optimize writing and flushing, if that Write()
+operation is not restricted.
+
+Note: Each new call of SetRestriction() sets new restictions,
+so previous restrction calls has no effect anymore.
+
+inputs:
+ 
+  (begin > end) is not allowed, and returns E_FAIL;
+  
+  if (begin == end)
+  {
+    No restriction.
+    The caller will call Write() in sequential order.
+    After SetRestriction(begin, begin), but before next call of SetRestriction()
+    {
+      Additional condition:
+        it's expected that current stream seek position is equal to stream size.
+      The callee can make final flushing for any data before current stream seek position.
+      For each Write(size) call:
+        The callee can make final flushing for that new written data.
+    }
+    The pair of values (begin == 0 && end == 0) is recommended to remove write restriction.
+  }
+  
+  if (begin < end)
+  {
+    it means that callee must NOT flush any data in region [begin, end).
+    The caller is allowed to Seek() to that region and rewrite the
+    data in that restriction region.
+    if (end == (UInt64)(Int64)-1)
+    {
+      there is no upper bound for restricted region.
+      So non-restricted region will be [0, begin) in that case
+    }
+  }
+
+ returns:
+  - if (begin > end) it return ERROR code (E_FAIL)
+  - S_OK : if no errors.
+  - Also the call of SetRestriction() can initiate the flushing of already written data.
+    So it can return the result of that flushing.
+ 
+ Note: IOutStream::SetSize() also can change the data.
+    So it's not expected the call
+    IOutStream::SetSize() to region that was written before as unrestricted.
+*/
+
+#define Z7_IFACEM_IStreamSetRestriction(x) \
+  x(SetRestriction(UInt64 begin, UInt64 end)) \
+
+Z7_IFACE_CONSTR_STREAM(IStreamSetRestriction, 0x10)
+
+Z7_PURE_INTERFACES_END
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/LzFindOpt.mak

@@ -0,0 +1,7 @@
+!IF defined(USE_C_LZFINDOPT) || "$(PLATFORM)" != "x64"
+C_OBJS = $(C_OBJS) \
+  $O\LzFindOpt.obj
+!ELSE
+ASM_OBJS = $(ASM_OBJS) \
+  $O\LzFindOpt.obj
+!ENDIF

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/LzmaDec.mak

@@ -0,0 +1,7 @@
+!IF "$(PLATFORM)" == "x64" || ("$(PLATFORM)" == "arm64" && !defined(NO_ASM_GNU))
+!IFNDEF NO_ASM
+CFLAGS_C_SPEC = -DZ7_LZMA_DEC_OPT
+ASM_OBJS = $(ASM_OBJS) \
+  $O\LzmaDecOpt.obj
+!ENDIF
+!ENDIF

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/LzmaDec_gcc.mak

@@ -0,0 +1,14 @@
+ifdef USE_ASM
+ifdef IS_X64
+USE_LZMA_DEC_ASM=1
+endif
+ifdef IS_ARM64
+USE_LZMA_DEC_ASM=1
+endif
+endif
+
+ifdef USE_LZMA_DEC_ASM
+
+LZMA_DEC_OPT_OBJS= $O/LzmaDecOpt.o
+
+endif

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

@@ -0,0 +1,2 @@
+#define USE_COPYRIGHT_CR
+#include "../../C/7zVersion.h"

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/MyVersionInfo.rc

@@ -0,0 +1,2 @@
+#include "MyVersion.h"
+#include "../../C/7zVersion.rc"

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

@@ -0,0 +1,178 @@
+// PropID.h
+
+#ifndef ZIP7_INC_7ZIP_PROP_ID_H
+#define ZIP7_INC_7ZIP_PROP_ID_H
+
+#include "../Common/MyTypes.h"
+
+enum
+{
+  kpidNoProperty = 0,
+  kpidMainSubfile,
+  kpidHandlerItemIndex,
+  kpidPath,
+  kpidName,
+  kpidExtension,
+  kpidIsDir,
+  kpidSize,
+  kpidPackSize,
+  kpidAttrib,
+  kpidCTime,
+  kpidATime,
+  kpidMTime,
+  kpidSolid,
+  kpidCommented,
+  kpidEncrypted,
+  kpidSplitBefore,
+  kpidSplitAfter,
+  kpidDictionarySize,
+  kpidCRC,
+  kpidType,
+  kpidIsAnti,
+  kpidMethod,
+  kpidHostOS,
+  kpidFileSystem,
+  kpidUser,
+  kpidGroup,
+  kpidBlock,
+  kpidComment,
+  kpidPosition,
+  kpidPrefix,
+  kpidNumSubDirs,
+  kpidNumSubFiles,
+  kpidUnpackVer,
+  kpidVolume,
+  kpidIsVolume,
+  kpidOffset,
+  kpidLinks,
+  kpidNumBlocks,
+  kpidNumVolumes,
+  kpidTimeType,
+  kpidBit64,
+  kpidBigEndian,
+  kpidCpu,
+  kpidPhySize,
+  kpidHeadersSize,
+  kpidChecksum,
+  kpidCharacts,
+  kpidVa,
+  kpidId,
+  kpidShortName,
+  kpidCreatorApp,
+  kpidSectorSize,
+  kpidPosixAttrib,
+  kpidSymLink,
+  kpidError,
+  kpidTotalSize,
+  kpidFreeSpace,
+  kpidClusterSize,
+  kpidVolumeName,
+  kpidLocalName,
+  kpidProvider,
+  kpidNtSecure,
+  kpidIsAltStream,
+  kpidIsAux,
+  kpidIsDeleted,
+  kpidIsTree,
+  kpidSha1,
+  kpidSha256,
+  kpidErrorType,
+  kpidNumErrors,
+  kpidErrorFlags,
+  kpidWarningFlags,
+  kpidWarning,
+  kpidNumStreams,
+  kpidNumAltStreams,
+  kpidAltStreamsSize,
+  kpidVirtualSize,
+  kpidUnpackSize,
+  kpidTotalPhySize,
+  kpidVolumeIndex,
+  kpidSubType,
+  kpidShortComment,
+  kpidCodePage,
+  kpidIsNotArcType,
+  kpidPhySizeCantBeDetected,
+  kpidZerosTailIsAllowed,
+  kpidTailSize,
+  kpidEmbeddedStubSize,
+  kpidNtReparse,
+  kpidHardLink,
+  kpidINode,
+  kpidStreamId,
+  kpidReadOnly,
+  kpidOutName,
+  kpidCopyLink,
+  kpidArcFileName,
+  kpidIsHash,
+  kpidChangeTime,
+  kpidUserId,
+  kpidGroupId,
+  kpidDeviceMajor,
+  kpidDeviceMinor,
+  kpidDevMajor,
+  kpidDevMinor,
+
+  kpid_NUM_DEFINED,
+
+  kpidUserDefined = 0x10000
+};
+
+extern const Byte k7z_PROPID_To_VARTYPE[kpid_NUM_DEFINED]; // VARTYPE
+
+const UInt32 kpv_ErrorFlags_IsNotArc              = 1 << 0;
+const UInt32 kpv_ErrorFlags_HeadersError          = 1 << 1;
+const UInt32 kpv_ErrorFlags_EncryptedHeadersError = 1 << 2;
+const UInt32 kpv_ErrorFlags_UnavailableStart      = 1 << 3;
+const UInt32 kpv_ErrorFlags_UnconfirmedStart      = 1 << 4;
+const UInt32 kpv_ErrorFlags_UnexpectedEnd         = 1 << 5;
+const UInt32 kpv_ErrorFlags_DataAfterEnd          = 1 << 6;
+const UInt32 kpv_ErrorFlags_UnsupportedMethod     = 1 << 7;
+const UInt32 kpv_ErrorFlags_UnsupportedFeature    = 1 << 8;
+const UInt32 kpv_ErrorFlags_DataError             = 1 << 9;
+const UInt32 kpv_ErrorFlags_CrcError              = 1 << 10;
+// const UInt32 kpv_ErrorFlags_Unsupported           = 1 << 11;
+
+/*
+linux ctime :
+   file metadata was last changed.
+   changing the file modification time
+   counts as a metadata change, so will also have the side effect of updating the ctime.
+
+PROPVARIANT for timestamps in 7-Zip:
+{
+  vt = VT_FILETIME
+  wReserved1: set precision level
+    0      : base value (backward compatibility value)
+             only filetime is used (7 digits precision).
+             wReserved2 and wReserved3 can contain random data
+    1      : Unix (1 sec)
+    2      : DOS  (2 sec)
+    3      : High Precision (1 ns)
+    16 - 3 : (reserved) = 1 day
+    16 - 2 : (reserved) = 1 hour
+    16 - 1 : (reserved) = 1 minute
+    16 + 0 : 1 sec (0 digits after point)
+    16 + (1,2,3,4,5,6,7,8,9) : set subsecond precision level :
+         (number of decimal digits after point)
+    16 + 9 : 1 ns  (9 digits after point)
+  wReserved2 = ns % 100 : if     (8 or 9 digits pecision)
+             = 0        : if not (8 or 9 digits pecision)
+  wReserved3 = 0;
+  filetime
+}
+
+NOTE: TAR-PAX archives created by GNU TAR don't keep
+  whole information about original level of precision,
+  and timestamp are stored in reduced form, where tail zero
+  digits after point are removed.
+  So 7-Zip can return different precision levels for different items for such TAR archives.
+*/
+
+/*
+TimePrec returned by IOutArchive::GetFileTimeType()
+is used only for updating, when we compare MTime timestamp
+from archive with timestamp from directory.
+*/
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Sha256.mak

@@ -0,0 +1,13 @@
+COMMON_OBJS = $(COMMON_OBJS) \
+  $O\Sha256Prepare.obj
+
+C_OBJS = $(C_OBJS) \
+  $O\Sha256.obj
+
+!IF defined(USE_C_SHA) || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+  $O\Sha256Opt.obj
+!ELSEIF "$(PLATFORM)" != "ia64" && "$(PLATFORM)" != "mips" && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
+ASM_OBJS = $(ASM_OBJS) \
+  $O\Sha256Opt.obj
+!ENDIF

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Sort.mak

@@ -0,0 +1,6 @@
+!IF defined(USE_NO_ASM) || defined(USE_C_SORT) || "$(PLATFORM)" == "ia64" || "$(PLATFORM)" == "mips" || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+!ELSE
+ASM_OBJS = $(ASM_OBJS) \
+!ENDIF
+  $O\Sort.obj

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/SubBuild.mak

@@ -0,0 +1,3 @@
+	cd $(@D)
+	$(MAKE) -nologo $(TARGETS)
+	cd ..