The Tor Browser: other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.cpp@97036ab72558 (annotated)

other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.cpp@97036ab72558 (annotated)

other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 // OpenArchive.cpp
 #include "StdAfx.h"
 #include "OpenArchive.h"
 #include "Common/Wildcard.h"
 #include "Windows/FileName.h"
 #include "Windows/FileDir.h"
 #include "Windows/Defs.h"
 #include "Windows/PropVariant.h"
 #include "../../Common/FileStreams.h"
 #include "../../Common/StreamUtils.h"
 #include "Common/StringConvert.h"
 #ifdef FORMAT_7Z
 #include "../../Archive/7z/7zHandler.h"
 #endif
 #ifdef FORMAT_BZIP2
 #include "../../Archive/BZip2/BZip2Handler.h"
 #endif
 #ifdef FORMAT_GZIP
 #include "../../Archive/GZip/GZipHandler.h"
 #endif
 #ifdef FORMAT_SPLIT
 #include "../../Archive/Split/SplitHandler.h"
 #endif
 #ifdef FORMAT_TAR
 #include "../../Archive/Tar/TarHandler.h"
 #endif
 #ifdef FORMAT_ZIP
 #include "../../Archive/Zip/ZipHandler.h"
 #endif
 #ifdef FORMAT_Z
 #include "../../Archive/Z/ZHandler.h"
 #endif
 #ifndef EXCLUDE_COM
 #include "HandlerLoader.h"
 #endif
 #include "DefaultName.h"
 using namespace NWindows;
 HRESULT GetArchiveItemPath(IInArchive *archive, UInt32 index, UString &result)
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetProperty(index, kpidPath, &prop));
   if(prop.vt == VT_BSTR)
     result = prop.bstrVal;
   else if (prop.vt == VT_EMPTY)
     result.Empty();
   else
     return E_FAIL;
   return S_OK;
 }
 HRESULT GetArchiveItemPath(IInArchive *archive, UInt32 index, const UString &defaultName, UString &result)
 {
   RINOK(GetArchiveItemPath(archive, index, result));
   if (result.IsEmpty())
     result = defaultName;
   return S_OK;
 }
 HRESULT GetArchiveItemFileTime(IInArchive *archive, UInt32 index,
     const FILETIME &defaultFileTime, FILETIME &fileTime)
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetProperty(index, kpidLastWriteTime, &prop));
   if (prop.vt == VT_FILETIME)
     fileTime = prop.filetime;
   else if (prop.vt == VT_EMPTY)
     fileTime = defaultFileTime;
   else
     return E_FAIL;
   return S_OK;
 }
 static HRESULT IsArchiveItemProp(IInArchive *archive, UInt32 index, PROPID propID, bool &result)
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetProperty(index, propID, &prop));
   if(prop.vt == VT_BOOL)
     result = VARIANT_BOOLToBool(prop.boolVal);
   else if (prop.vt == VT_EMPTY)
     result = false;
   else
     return E_FAIL;
   return S_OK;
 }
 HRESULT IsArchiveItemFolder(IInArchive *archive, UInt32 index, bool &result)
 {
   return IsArchiveItemProp(archive, index, kpidIsFolder, result);
 }
 HRESULT IsArchiveItemAnti(IInArchive *archive, UInt32 index, bool &result)
 {
   return IsArchiveItemProp(archive, index, kpidIsAnti, result);
 }
 // Static-SFX (for Linux) can be big
 const UInt64 kMaxCheckStartPosition =
 #ifdef _WIN32
 << 20;
 #else
 << 22;
 #endif
 HRESULT ReOpenArchive(IInArchive *archive, const UString &fileName)
 {
   CInFileStream *inStreamSpec = new CInFileStream;
   CMyComPtr<IInStream> inStream(inStreamSpec);
   inStreamSpec->Open(fileName);
   return archive->Open(inStream, &kMaxCheckStartPosition, NULL);
 }
 #ifndef _SFX
 static inline bool TestSignature(const Byte *p1, const Byte *p2, size_t size)
 {
   for (size_t i = 0; i < size; i++)
     if (p1[i] != p2[i])
       return false;
   return true;
 }
 #endif
 HRESULT OpenArchive(
     IInStream *inStream,
     const UString &fileName,
     #ifndef EXCLUDE_COM
     HMODULE *module,
     #endif
     IInArchive **archiveResult,
     CArchiverInfo &archiverInfoResult,
     UString &defaultItemName,
     IArchiveOpenCallback *openArchiveCallback)
 {
   *archiveResult = NULL;
   CObjectVector<CArchiverInfo> archiverInfoList;
   ReadArchiverInfoList(archiverInfoList);
   UString extension;
   {
     int dotPos = fileName.ReverseFind(L'.');
     if (dotPos >= 0)
       extension = fileName.Mid(dotPos + 1);
   }
   CIntVector orderIndices;
   int i;
   bool finded = false;
   for(i = 0; i < archiverInfoList.Size(); i++)
   {
     if (archiverInfoList[i].FindExtension(extension) >= 0)
     {
       orderIndices.Insert(0, i);
       finded = true;
     }
     else
       orderIndices.Add(i);
   }
   #ifndef _SFX
   if (!finded)
   {
     CByteBuffer byteBuffer;
     const UInt32 kBufferSize = (200 << 10);
     byteBuffer.SetCapacity(kBufferSize);
     Byte *buffer = byteBuffer;
     RINOK(inStream->Seek(0, STREAM_SEEK_SET, NULL));
     UInt32 processedSize;
     RINOK(ReadStream(inStream, buffer, kBufferSize, &processedSize));
     int numFinded = 0;
     for (int pos = (int)processedSize; pos >= 0 ; pos--)
     {
       for(int i = numFinded; i < orderIndices.Size(); i++)
       {
         int index = orderIndices[i];
         const CArchiverInfo &ai = archiverInfoList[index];
         const CByteBuffer &sig = ai.StartSignature;
         if (sig.GetCapacity() == 0)
           continue;
         if (pos + sig.GetCapacity() > processedSize)
           continue;
         if (TestSignature(buffer + pos, sig, sig.GetCapacity()))
         {
           orderIndices.Delete(i);
           orderIndices.Insert(0, index);
           numFinded++;
         }
       }
     }
   }
   #endif
   HRESULT badResult = S_OK;
   for(i = 0; i < orderIndices.Size(); i++)
   {
     inStream->Seek(0, STREAM_SEEK_SET, NULL);
     const CArchiverInfo &archiverInfo = archiverInfoList[orderIndices[i]];
     #ifndef EXCLUDE_COM
     CHandlerLoader loader;
     #endif
     CMyComPtr<IInArchive> archive;
     #ifdef FORMAT_7Z
     if (archiverInfo.Name.CompareNoCase(L"7z") == 0)
       archive = new NArchive::N7z::CHandler;
     #endif
     #ifdef FORMAT_BZIP2
     if (archiverInfo.Name.CompareNoCase(L"BZip2") == 0)
       archive = new NArchive::NBZip2::CHandler;
     #endif
     #ifdef FORMAT_GZIP
     if (archiverInfo.Name.CompareNoCase(L"GZip") == 0)
       archive = new NArchive::NGZip::CHandler;
     #endif
     #ifdef FORMAT_SPLIT
     if (archiverInfo.Name.CompareNoCase(L"Split") == 0)
       archive = new NArchive::NSplit::CHandler;
     #endif
     #ifdef FORMAT_TAR
     if (archiverInfo.Name.CompareNoCase(L"Tar") == 0)
       archive = new NArchive::NTar::CHandler;
     #endif
     #ifdef FORMAT_ZIP
     if (archiverInfo.Name.CompareNoCase(L"Zip") == 0)
       archive = new NArchive::NZip::CHandler;
     #endif
     #ifdef FORMAT_Z
     if (archiverInfo.Name.CompareNoCase(L"Z") == 0)
       archive = new NArchive::NZ::CHandler;
     #endif
     #ifndef EXCLUDE_COM
     if (!archive)
     {
       HRESULT result = loader.CreateHandler(archiverInfo.FilePath,
           archiverInfo.ClassID, (void **)&archive, false);
       if (result != S_OK)
         continue;
     }
     #endif
     if (!archive)
       return E_FAIL;
     HRESULT result = archive->Open(inStream, &kMaxCheckStartPosition, openArchiveCallback);
     if(result == S_FALSE)
       continue;
     if(result != S_OK)
     {
       badResult = result;
       if(result == E_ABORT)
         break;
       continue;
     }
     *archiveResult = archive.Detach();
     #ifndef EXCLUDE_COM
     *module = loader.Detach();
     #endif
     archiverInfoResult = archiverInfo;
     int subExtIndex = archiverInfo.FindExtension(extension);
     if (subExtIndex < 0)
       subExtIndex = 0;
     defaultItemName = GetDefaultName2(fileName,
         archiverInfo.Extensions[subExtIndex].Ext,
         archiverInfo.Extensions[subExtIndex].AddExt);
     return S_OK;
   }
   if (badResult != S_OK)
     return badResult;
   return S_FALSE;
 }
 HRESULT OpenArchive(const UString &filePath,
     #ifndef EXCLUDE_COM
     HMODULE *module,
     #endif
     IInArchive **archiveResult,
     CArchiverInfo &archiverInfo,
     UString &defaultItemName,
     IArchiveOpenCallback *openArchiveCallback)
 {
   CInFileStream *inStreamSpec = new CInFileStream;
   CMyComPtr<IInStream> inStream(inStreamSpec);
   if (!inStreamSpec->Open(filePath))
     return GetLastError();
   return OpenArchive(inStream, ExtractFileNameFromPath(filePath),
     #ifndef EXCLUDE_COM
     module,
     #endif
     archiveResult, archiverInfo,
     defaultItemName, openArchiveCallback);
 }
 static void MakeDefaultName(UString &name)
 {
   int dotPos = name.ReverseFind(L'.');
   if (dotPos < 0)
     return;
   UString ext = name.Mid(dotPos + 1);
   if (ext.IsEmpty())
     return;
   for (int pos = 0; pos < ext.Length(); pos++)
     if (ext[pos] < L'0' || ext[pos] > L'9')
       return;
   name = name.Left(dotPos);
 }
 HRESULT OpenArchive(const UString &fileName,
     #ifndef EXCLUDE_COM
     HMODULE *module0,
     HMODULE *module1,
     #endif
     IInArchive **archive0,
     IInArchive **archive1,
     CArchiverInfo &archiverInfo0,
     CArchiverInfo &archiverInfo1,
     UString &defaultItemName0,
     UString &defaultItemName1,
     IArchiveOpenCallback *openArchiveCallback)
 {
   HRESULT result = OpenArchive(fileName,
     #ifndef EXCLUDE_COM
     module0,
     #endif
     archive0, archiverInfo0, defaultItemName0, openArchiveCallback);
   RINOK(result);
   CMyComPtr<IInArchiveGetStream> getStream;
   result = (*archive0)->QueryInterface(IID_IInArchiveGetStream, (void **)&getStream);
   if (result != S_OK || getStream == 0)
     return S_OK;
   CMyComPtr<ISequentialInStream> subSeqStream;
   result = getStream->GetStream(0, &subSeqStream);
   if (result != S_OK)
     return S_OK;
   CMyComPtr<IInStream> subStream;
   if (subSeqStream.QueryInterface(IID_IInStream, &subStream) != S_OK)
     return S_OK;
   if (!subStream)
     return S_OK;
   UInt32 numItems;
   RINOK((*archive0)->GetNumberOfItems(&numItems));
   if (numItems < 1)
     return S_OK;
   UString subPath;
   RINOK(GetArchiveItemPath(*archive0, 0, subPath))
   if (subPath.IsEmpty())
   {
     MakeDefaultName(defaultItemName0);
     subPath = defaultItemName0;
     if (archiverInfo0.Name.CompareNoCase(L"7z") == 0)
     {
       if (subPath.Right(3).CompareNoCase(L".7z") != 0)
         subPath += L".7z";
     }
   }
   else
     subPath = ExtractFileNameFromPath(subPath);
   CMyComPtr<IArchiveOpenSetSubArchiveName> setSubArchiveName;
   openArchiveCallback->QueryInterface(IID_IArchiveOpenSetSubArchiveName, (void **)&setSubArchiveName);
   if (setSubArchiveName)
     setSubArchiveName->SetSubArchiveName(subPath);
   result = OpenArchive(subStream, subPath,
     #ifndef EXCLUDE_COM
     module1,
     #endif
     archive1, archiverInfo1, defaultItemName1, openArchiveCallback);
   return S_OK;
 }
 HRESULT MyOpenArchive(const UString &archiveName,
     #ifndef EXCLUDE_COM
     HMODULE *module,
     #endif
     IInArchive **archive,
     UString &defaultItemName,
     IOpenCallbackUI *openCallbackUI)
 {
   COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
   CMyComPtr<IArchiveOpenCallback> openCallback = openCallbackSpec;
   openCallbackSpec->Callback = openCallbackUI;
   UString fullName;
   int fileNamePartStartIndex;
   NFile::NDirectory::MyGetFullPathName(archiveName, fullName, fileNamePartStartIndex);
   openCallbackSpec->Init(
       fullName.Left(fileNamePartStartIndex),
       fullName.Mid(fileNamePartStartIndex));
   CArchiverInfo archiverInfo;
   return OpenArchive(archiveName,
       #ifndef EXCLUDE_COM
       module,
       #endif
       archive,
       archiverInfo,
       defaultItemName,
       openCallback);
 }
 HRESULT MyOpenArchive(const UString &archiveName,
     #ifndef EXCLUDE_COM
     HMODULE *module0,
     HMODULE *module1,
     #endif
     IInArchive **archive0,
     IInArchive **archive1,
     UString &defaultItemName0,
     UString &defaultItemName1,
     UStringVector &volumePaths,
     IOpenCallbackUI *openCallbackUI)
 {
   COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
   CMyComPtr<IArchiveOpenCallback> openCallback = openCallbackSpec;
   openCallbackSpec->Callback = openCallbackUI;
   UString fullName;
   int fileNamePartStartIndex;
   NFile::NDirectory::MyGetFullPathName(archiveName, fullName, fileNamePartStartIndex);
   UString prefix = fullName.Left(fileNamePartStartIndex);
   UString name = fullName.Mid(fileNamePartStartIndex);
   openCallbackSpec->Init(prefix, name);
   CArchiverInfo archiverInfo0, archiverInfo1;
   HRESULT result = OpenArchive(archiveName,
       #ifndef EXCLUDE_COM
       module0,
       module1,
       #endif
       archive0,
       archive1,
       archiverInfo0,
       archiverInfo1,
       defaultItemName0,
       defaultItemName1,
       openCallback);
   RINOK(result);
   volumePaths.Add(prefix + name);
   for (int i = 0; i < openCallbackSpec->FileNames.Size(); i++)
     volumePaths.Add(prefix + openCallbackSpec->FileNames[i]);
   return S_OK;
 }
 HRESULT CArchiveLink::Close()
 {
   if (Archive1 != 0)
     RINOK(Archive1->Close());
   if (Archive0 != 0)
     RINOK(Archive0->Close());
   return S_OK;
 }
 void CArchiveLink::Release()
 {
   if (Archive1 != 0)
     Archive1.Release();
   if (Archive0 != 0)
     Archive0.Release();
   #ifndef EXCLUDE_COM
   Library1.Free();
   Library0.Free();
   #endif
 }
 HRESULT OpenArchive(const UString &archiveName,
     CArchiveLink &archiveLink,
     IArchiveOpenCallback *openCallback)
 {
   return OpenArchive(archiveName,
     #ifndef EXCLUDE_COM
     &archiveLink.Library0, &archiveLink.Library1,
     #endif
     &archiveLink.Archive0, &archiveLink.Archive1,
     archiveLink.ArchiverInfo0, archiveLink.ArchiverInfo1,
     archiveLink.DefaultItemName0, archiveLink.DefaultItemName1,
     openCallback);
 }
 HRESULT MyOpenArchive(const UString &archiveName,
     CArchiveLink &archiveLink,
     IOpenCallbackUI *openCallbackUI)
 {
   return MyOpenArchive(archiveName,
     #ifndef EXCLUDE_COM
     &archiveLink.Library0, &archiveLink.Library1,
     #endif
     &archiveLink.Archive0, &archiveLink.Archive1,
     archiveLink.DefaultItemName0, archiveLink.DefaultItemName1,
     archiveLink.VolumePaths,
     openCallbackUI);
 }
 HRESULT ReOpenArchive(CArchiveLink &archiveLink,
     const UString &fileName)
 {
   if (archiveLink.GetNumLevels() > 1)
     return E_NOTIMPL;
   if (archiveLink.GetNumLevels() == 0)
     return MyOpenArchive(fileName, archiveLink, 0);
   return ReOpenArchive(archiveLink.GetArchive(), fileName);
 }

The Tor Browser / annotate

other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.cpp@97036ab72558 (annotated)

other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.cpp