react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Common/WorkDir.cpp

@@ -0,0 +1,84 @@
+// WorkDir.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileSystem.h"
+
+#include "WorkDir.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+FString GetWorkDir(const NWorkDir::CInfo &workDirInfo, const FString &path, FString &fileName)
+{
+  NWorkDir::NMode::EEnum mode = workDirInfo.Mode;
+  
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  if (workDirInfo.ForRemovableOnly)
+  {
+    mode = NWorkDir::NMode::kCurrent;
+    const FString prefix = path.Left(3);
+    if (NName::IsDrivePath(prefix))
+    {
+      const UINT driveType = NSystem::MyGetDriveType(prefix);
+      if (driveType == DRIVE_CDROM || driveType == DRIVE_REMOVABLE)
+        mode = workDirInfo.Mode;
+    }
+    /*
+    CParsedPath parsedPath;
+    parsedPath.ParsePath(archiveName);
+    UINT driveType = GetDriveType(parsedPath.Prefix);
+    if ((driveType != DRIVE_CDROM) && (driveType != DRIVE_REMOVABLE))
+      mode = NZipSettings::NWorkDir::NMode::kCurrent;
+    */
+  }
+  #endif
+  
+  const int pos = path.ReverseFind_PathSepar() + 1;
+  fileName = path.Ptr((unsigned)pos);
+  
+  FString tempDir;
+  switch ((int)mode)
+  {
+    case NWorkDir::NMode::kCurrent:
+      tempDir = path.Left((unsigned)pos);
+      break;
+    case NWorkDir::NMode::kSpecified:
+      tempDir = workDirInfo.Path;
+      break;
+    // case NWorkDir::NMode::kSystem:
+    default:
+      if (!MyGetTempPath(tempDir))
+        throw 141717;
+      break;
+  }
+  NName::NormalizeDirPathPrefix(tempDir);
+  return tempDir;
+}
+
+HRESULT CWorkDirTempFile::CreateTempFile(const FString &originalPath)
+{
+  NWorkDir::CInfo workDirInfo;
+  workDirInfo.Load();
+  FString namePart;
+  FString path = GetWorkDir(workDirInfo, originalPath, namePart);
+  CreateComplexDir(path);
+  path += namePart;
+  _outStreamSpec = new COutFileStream;
+  OutStream = _outStreamSpec;
+  if (!_tempFile.Create(path, &_outStreamSpec->File))
+    return GetLastError_noZero_HRESULT();
+  _originalPath = originalPath;
+  return S_OK;
+}
+
+HRESULT CWorkDirTempFile::MoveToOriginal(bool deleteOriginal,
+    NWindows::NFile::NDir::ICopyFileProgress *progress)
+{
+  OutStream.Release();
+  if (!_tempFile.MoveTo(_originalPath, deleteOriginal, progress))
+    return GetLastError_noZero_HRESULT();
+  return S_OK;
+}

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Common/WorkDir.h

@@ -0,0 +1,30 @@
+// WorkDir.h
+
+#ifndef ZIP7_INC_WORK_DIR_H
+#define ZIP7_INC_WORK_DIR_H
+
+#include "../../../Windows/FileDir.h"
+
+#include "../../Common/FileStreams.h"
+
+#include "ZipRegistry.h"
+
+FString GetWorkDir(const NWorkDir::CInfo &workDirInfo, const FString &path, FString &fileName);
+
+class CWorkDirTempFile  MY_UNCOPYABLE
+{
+  FString _originalPath;
+  NWindows::NFile::NDir::CTempFile _tempFile;
+  COutFileStream *_outStreamSpec;
+public:
+  CMyComPtr<IOutStream> OutStream;
+
+  const FString &Get_OriginalFilePath() const { return _originalPath; }
+  const FString &Get_TempFilePath() const { return _tempFile.GetPath(); }
+
+  HRESULT CreateTempFile(const FString &originalPath);
+  HRESULT MoveToOriginal(bool deleteOriginal,
+      NWindows::NFile::NDir::ICopyFileProgress *progress = NULL);
+};
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Common/ZipRegistry.h

@@ -0,0 +1,212 @@
+// ZipRegistry.h
+
+#ifndef ZIP7_INC_ZIP_REGISTRY_H
+#define ZIP7_INC_ZIP_REGISTRY_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+#include "../../Common/MethodProps.h"
+
+#include "ExtractMode.h"
+
+/*
+CBoolPair::Def in writing functions means:
+  if (  CBoolPair::Def ), we write CBoolPair::Val
+  if ( !CBoolPair::Def )
+  {
+    in NCompression functions we delete registry value
+    in another functions we do nothing
+  }
+*/
+
+namespace NExtract
+{
+  struct CInfo
+  {
+    NPathMode::EEnum PathMode;
+    NOverwriteMode::EEnum OverwriteMode;
+    bool PathMode_Force;
+    bool OverwriteMode_Force;
+    
+    CBoolPair SplitDest;
+    CBoolPair ElimDup;
+    // CBoolPair AltStreams;
+    CBoolPair NtSecurity;
+    CBoolPair ShowPassword;
+
+    UStringVector Paths;
+
+    void Save() const;
+    void Load();
+  };
+  
+  void Save_ShowPassword(bool showPassword);
+  bool Read_ShowPassword();
+
+  void Save_LimitGB(UInt32 limit_GB);
+  UInt32 Read_LimitGB();
+}
+
+namespace NCompression
+{
+  struct CMemUse
+  {
+    // UString Str;
+    bool IsDefined;
+    bool IsPercent;
+    UInt64 Val;
+
+    CMemUse():
+      IsDefined(false),
+      IsPercent(false),
+      Val(0)
+      {}
+
+    void Clear()
+    {
+      // Str.Empty();
+      IsDefined = false;
+      IsPercent = false;
+      Val = 0;
+    }
+
+    UInt64 GetBytes(UInt64 ramSize) const
+    {
+      if (!IsPercent)
+        return Val;
+      return Calc_From_Val_Percents(ramSize, Val);
+    }
+    void Parse(const UString &s);
+  };
+
+  struct CFormatOptions
+  {
+    UInt32 Level;
+    UInt32 Dictionary;
+    // UInt32 DictionaryChain;
+    UInt32 Order;
+    UInt32 BlockLogSize;
+    UInt32 NumThreads;
+    
+    UInt32 TimePrec;
+    CBoolPair MTime;
+    CBoolPair ATime;
+    CBoolPair CTime;
+    CBoolPair SetArcMTime;
+
+    CSysString FormatID;
+    UString Method;
+    UString Options;
+    UString EncryptionMethod;
+    UString MemUse;
+
+    void Reset_TimePrec()
+    {
+      TimePrec = (UInt32)(Int32)-1;
+    }
+
+    bool IsSet_TimePrec() const
+    {
+      return TimePrec != (UInt32)(Int32)-1;
+    }
+
+
+    void Reset_BlockLogSize()
+    {
+      BlockLogSize = (UInt32)(Int32)-1;
+    }
+
+    void ResetForLevelChange()
+    {
+      BlockLogSize = NumThreads = Level = Dictionary = Order = (UInt32)(Int32)-1;
+      // DictionaryChain = (UInt32)(Int32)-1;
+      Method.Empty();
+      // Options.Empty();
+      // EncryptionMethod.Empty();
+    }
+    CFormatOptions()
+    {
+      // TimePrec = 0;
+      Reset_TimePrec();
+      ResetForLevelChange();
+    }
+  };
+
+  struct CInfo
+  {
+    UInt32 Level;
+    bool ShowPassword;
+    bool EncryptHeaders;
+
+    CBoolPair NtSecurity;
+    CBoolPair AltStreams;
+    CBoolPair HardLinks;
+    CBoolPair SymLinks;
+
+    CBoolPair PreserveATime;
+
+    UString ArcType;
+    UStringVector ArcPaths;
+
+    CObjectVector<CFormatOptions> Formats;
+
+    void Save() const;
+    void Load();
+  };
+}
+
+namespace NWorkDir
+{
+  namespace NMode
+  {
+    enum EEnum
+    {
+      kSystem,
+      kCurrent,
+      kSpecified
+    };
+  }
+  struct CInfo
+  {
+    NMode::EEnum Mode;
+    bool ForRemovableOnly;
+    FString Path;
+
+    void SetForRemovableOnlyDefault() { ForRemovableOnly = true; }
+    void SetDefault()
+    {
+      Mode = NMode::kSystem;
+      Path.Empty();
+      SetForRemovableOnlyDefault();
+    }
+
+    void Save() const;
+    void Load();
+  };
+}
+
+
+struct CContextMenuInfo
+{
+  CBoolPair Cascaded;
+  CBoolPair MenuIcons;
+  CBoolPair ElimDup;
+  
+  bool Flags_Def;
+  UInt32 Flags;
+  UInt32 WriteZone;
+
+  /*
+  CContextMenuInfo():
+      Flags_Def(0),
+      WriteZone((UInt32)(Int32)-1),
+      Flags((UInt32)(Int32)-1)
+      {}
+  */
+
+  void Save() const;
+  void Load();
+};
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Console/BenchCon.cpp

@@ -0,0 +1,41 @@
+// BenchCon.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/Bench.h"
+
+#include "BenchCon.h"
+#include "ConsoleClose.h"
+
+struct CPrintBenchCallback Z7_final: public IBenchPrintCallback
+{
+  FILE *_file;
+
+  void Print(const char *s) Z7_override;
+  void NewLine() Z7_override;
+  HRESULT CheckBreak() Z7_override;
+};
+
+void CPrintBenchCallback::Print(const char *s)
+{
+  fputs(s, _file);
+}
+
+void CPrintBenchCallback::NewLine()
+{
+  fputc('\n', _file);
+}
+
+HRESULT CPrintBenchCallback::CheckBreak()
+{
+  return NConsoleClose::TestBreakSignal() ? E_ABORT: S_OK;
+}
+
+HRESULT BenchCon(DECL_EXTERNAL_CODECS_LOC_VARS
+    const CObjectVector<CProperty> &props, UInt32 numIterations, FILE *f)
+{
+  CPrintBenchCallback callback;
+  callback._file = f;
+  return Bench(EXTERNAL_CODECS_LOC_VARS
+      &callback, NULL, props, numIterations, true);
+}

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Console/BenchCon.h

@@ -0,0 +1,14 @@
+// BenchCon.h
+
+#ifndef ZIP7_INC_BENCH_CON_H
+#define ZIP7_INC_BENCH_CON_H
+
+#include <stdio.h>
+
+#include "../../Common/CreateCoder.h"
+#include "../../UI/Common/Property.h"
+
+HRESULT BenchCon(DECL_EXTERNAL_CODECS_LOC_VARS
+    const CObjectVector<CProperty> &props, UInt32 numIterations, FILE *f);
+
+#endif

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

@@ -0,0 +1,46 @@
+MY_CONSOLE = 1
+
+!IFNDEF UNDER_CE
+CFLAGS = $(CFLAGS) -DZ7_DEVICE_FILE
+# -DZ7_LONG_PATH -DZ7_LARGE_PAGES
+!ENDIF
+
+CONSOLE_OBJS = \
+  $O\BenchCon.obj \
+  $O\ConsoleClose.obj \
+  $O\ExtractCallbackConsole.obj \
+  $O\HashCon.obj \
+  $O\List.obj \
+  $O\Main.obj \
+  $O\MainAr.obj \
+  $O\OpenCallbackConsole.obj \
+  $O\PercentPrinter.obj \
+  $O\UpdateCallbackConsole.obj \
+  $O\UserInputUtils.obj \
+
+UI_COMMON_OBJS = \
+  $O\ArchiveCommandLine.obj \
+  $O\ArchiveExtractCallback.obj \
+  $O\ArchiveOpenCallback.obj \
+  $O\Bench.obj \
+  $O\DefaultName.obj \
+  $O\EnumDirItems.obj \
+  $O\Extract.obj \
+  $O\ExtractingFilePath.obj \
+  $O\HashCalc.obj \
+  $O\LoadCodecs.obj \
+  $O\OpenArchive.obj \
+  $O\PropIDUtils.obj \
+  $O\SetProperties.obj \
+  $O\SortUtils.obj \
+  $O\TempFiles.obj \
+  $O\Update.obj \
+  $O\UpdateAction.obj \
+  $O\UpdateCallback.obj \
+  $O\UpdatePair.obj \
+  $O\UpdateProduce.obj \
+
+C_OBJS = $(C_OBJS) \
+  $O\DllSecur.obj \
+
+# we need empty line after last line above

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Console/Console.manifest

@@ -0,0 +1,16 @@
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7z" type="win32"></assemblyIdentity>
+<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+<security><requestedPrivileges><requestedExecutionLevel level="asInvoker" uiAccess="false">
+</requestedExecutionLevel></requestedPrivileges></security></trustInfo>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
+<!-- Vista   --> <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+<!-- Win 7   --> <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+<!-- Win 8   --> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+<!-- Win 8.1 --> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+<!-- Win 10  --> <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+</application></compatibility>
+<application xmlns="urn:schemas-microsoft-com:asm.v3">
+<windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
+<ws2:longPathAware>true</ws2:longPathAware></windowsSettings></application>
+</assembly>

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Console/ConsoleClose.cpp

@@ -0,0 +1,98 @@
+// ConsoleClose.cpp
+
+#include "StdAfx.h"
+
+#include "ConsoleClose.h"
+
+#ifndef UNDER_CE
+
+#ifdef _WIN32
+#include "../../../Common/MyWindows.h"
+#else
+#include <stdlib.h>
+#include <signal.h>
+#endif
+
+namespace NConsoleClose {
+
+unsigned g_BreakCounter = 0;
+static const unsigned kBreakAbortThreshold = 3;
+
+#ifdef _WIN32
+
+static BOOL WINAPI HandlerRoutine(DWORD ctrlType)
+{
+  if (ctrlType == CTRL_LOGOFF_EVENT)
+  {
+    // printf("\nCTRL_LOGOFF_EVENT\n");
+    return TRUE;
+  }
+
+  if (++g_BreakCounter < kBreakAbortThreshold)
+    return TRUE;
+  return FALSE;
+  /*
+  switch (ctrlType)
+  {
+    case CTRL_C_EVENT:
+    case CTRL_BREAK_EVENT:
+      if (g_BreakCounter < kBreakAbortThreshold)
+      return TRUE;
+  }
+  return FALSE;
+  */
+}
+
+CCtrlHandlerSetter::CCtrlHandlerSetter()
+{
+  if (!SetConsoleCtrlHandler(HandlerRoutine, TRUE))
+    throw 1019; // "SetConsoleCtrlHandler fails";
+}
+
+CCtrlHandlerSetter::~CCtrlHandlerSetter()
+{
+  if (!SetConsoleCtrlHandler(HandlerRoutine, FALSE))
+  {
+    // warning for throw in destructor.
+    // throw "SetConsoleCtrlHandler fails";
+  }
+}
+
+#else // _WIN32
+
+static void HandlerRoutine(int)
+{
+  if (++g_BreakCounter < kBreakAbortThreshold)
+    return;
+  exit(EXIT_FAILURE);
+}
+
+CCtrlHandlerSetter::CCtrlHandlerSetter()
+{
+  memo_sig_int = signal(SIGINT, HandlerRoutine); // CTRL-C
+  if (memo_sig_int == SIG_ERR)
+    throw "SetConsoleCtrlHandler fails (SIGINT)";
+  memo_sig_term = signal(SIGTERM, HandlerRoutine); // for kill -15 (before "kill -9")
+  if (memo_sig_term == SIG_ERR)
+    throw "SetConsoleCtrlHandler fails (SIGTERM)";
+}
+
+CCtrlHandlerSetter::~CCtrlHandlerSetter()
+{
+  signal(SIGINT, memo_sig_int); // CTRL-C
+  signal(SIGTERM, memo_sig_term); // kill {pid}
+}
+
+#endif // _WIN32
+
+/*
+void CheckCtrlBreak()
+{
+  if (TestBreakSignal())
+    throw CCtrlBreakException();
+}
+*/
+
+}
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Console/ConsoleClose.h

@@ -0,0 +1,39 @@
+// ConsoleClose.h
+
+#ifndef ZIP7_INC_CONSOLE_CLOSE_H
+#define ZIP7_INC_CONSOLE_CLOSE_H
+
+namespace NConsoleClose {
+
+// class CCtrlBreakException {};
+
+#ifdef UNDER_CE
+
+inline bool TestBreakSignal() { return false; }
+struct CCtrlHandlerSetter {};
+
+#else
+
+extern unsigned g_BreakCounter;
+
+inline bool TestBreakSignal()
+{
+  return (g_BreakCounter != 0);
+}
+
+class CCtrlHandlerSetter Z7_final
+{
+  #ifndef _WIN32
+  void (*memo_sig_int)(int);
+  void (*memo_sig_term)(int);
+  #endif
+public:
+  CCtrlHandlerSetter();
+  ~CCtrlHandlerSetter();
+};
+
+#endif
+
+}
+
+#endif