STDMETHODIMP CHandler::Extract(const UInt32* indices, UInt32 numItems, Int32 _aTestMode, IArchiveExtractCallback *extractCallback) { COM_TRY_BEGIN bool testMode = (_aTestMode != 0); bool allFilesMode = (numItems == UInt32(-1)); if (allFilesMode) numItems = _sections.Size(); if (numItems == 0) return S_OK; UInt64 totalSize = 0; UInt32 i; for (i = 0; i < numItems; i++) totalSize += _sections[allFilesMode ? i : indices[i]].PSize; extractCallback->SetTotal(totalSize); UInt64 currentTotalSize = 0; UInt64 currentItemSize; NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder(); CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec; CLocalProgress *lps = new CLocalProgress; CMyComPtr<ICompressProgressInfo> progress = lps; lps->Init(extractCallback, false); CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream; CMyComPtr<ISequentialInStream> inStream(streamSpec); streamSpec->SetStream(_inStream); for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize) { lps->InSize = lps->OutSize = currentTotalSize; RINOK(lps->SetCur()); Int32 askMode = testMode ? NArchive::NExtract::NAskMode::kTest : NArchive::NExtract::NAskMode::kExtract; UInt32 index = allFilesMode ? i : indices[i]; const CSegment &item = _sections[index]; currentItemSize = item.PSize; CMyComPtr<ISequentialOutStream> outStream; RINOK(extractCallback->GetStream(index, &outStream, askMode)); if (!testMode && !outStream) continue; RINOK(extractCallback->PrepareOperation(askMode)); RINOK(_inStream->Seek(item.Offset, STREAM_SEEK_SET, NULL)); streamSpec->Init(currentItemSize); RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress)); outStream.Release(); RINOK(extractCallback->SetOperationResult(copyCoderSpec->TotalSize == currentItemSize ? NArchive::NExtract::NOperationResult::kOK: NArchive::NExtract::NOperationResult::kDataError)); } return S_OK; COM_TRY_END }
HRESULT CFSFolder::BindToFolderSpec(const wchar_t *name, IFolderFolder **resultFolder) { *resultFolder = 0; CFSFolder *folderSpec = new CFSFolder; CMyComPtr<IFolderFolder> subFolder = folderSpec; RINOK(folderSpec->Init(_path + name + UString(WCHAR_PATH_SEPARATOR), 0)); *resultFolder = subFolder.Detach(); return S_OK; }
HRESULT CUpdateCallbackAgent::CryptoGetTextPassword(BSTR *password) { *password = NULL; CMyComPtr<ICryptoGetTextPassword> getTextPassword; Callback.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword); if (!getTextPassword) return E_NOTIMPL; return getTextPassword->CryptoGetTextPassword(password); }
HRESULT CFSFolder::BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder) { *resultFolder = 0; CFSFolder *folderSpec = new CFSFolder; CMyComPtr<IFolderFolder> subFolder = folderSpec; RINOK(folderSpec->Init(_path + name + FCHAR_PATH_SEPARATOR)); *resultFolder = subFolder.Detach(); return S_OK; }
void CItemIDList::Free() { if(m_Object == NULL) return; CMyComPtr<IMalloc> shellMalloc; if(::SHGetMalloc(&shellMalloc) != NOERROR) throw 41099; shellMalloc->Free(m_Object); m_Object = NULL; }
void BitMemExtractor::extract( const vector< byte_t >& in_buffer, const wstring& out_dir ) const { CMyComPtr< IInArchive > inArchive = openArchive( mLibrary, mFormat, in_buffer, *this ); ExtractCallback* extractCallbackSpec = new ExtractCallback( *this, inArchive, out_dir ); CMyComPtr< IArchiveExtractCallback > extractCallback( extractCallbackSpec ); if ( inArchive->Extract( NULL, static_cast< UInt32 >( -1 ), false, extractCallback ) != S_OK ) { throw BitException( extractCallbackSpec->getErrorMessage() ); } }
HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream) { *resStream = 0; CLimitedInStream *streamSpec = new CLimitedInStream; CMyComPtr<ISequentialInStream> streamTemp = streamSpec; streamSpec->SetStream(inStream); RINOK(streamSpec->InitAndSeek(pos, size)); streamSpec->SeekToStart(); *resStream = streamTemp.Detach(); return S_OK; }
HRESULT UpdateArchive(UInt64 unpackSize, ISequentialOutStream *outStream, int indexInClient, UInt32 numPasses, IArchiveUpdateCallback *updateCallback) { RINOK(updateCallback->SetTotal(unpackSize)); UInt64 complexity = 0; RINOK(updateCallback->SetCompleted(&complexity)); CMyComPtr<ISequentialInStream> fileInStream; RINOK(updateCallback->GetStream(indexInClient, &fileInStream)); CLocalProgress *localProgressSpec = new CLocalProgress; CMyComPtr<ICompressProgressInfo> localProgress = localProgressSpec; localProgressSpec->Init(updateCallback, true); #ifndef COMPRESS_BZIP2 CCoderLibrary lib; #endif CMyComPtr<ICompressCoder> encoder; #ifdef COMPRESS_BZIP2 encoder = new NCompress::NBZip2::CEncoder; #else RINOK(lib.LoadAndCreateCoder(GetBZip2CodecPath(), CLSID_CCompressBZip2Encoder, &encoder)); #endif CMyComPtr<ICompressSetCoderProperties> setCoderProperties; encoder.QueryInterface(IID_ICompressSetCoderProperties, &setCoderProperties); if (setCoderProperties) { /* NWindows::NCOM::CPropVariant properties[2] = { dictionary, numPasses }; PROPID propIDs[2] = { NCoderPropID::kDictionarySize, NCoderPropID::kNumPasses, }; RINOK(setCoderProperties->SetCoderProperties(propIDs, properties, 2)); */ NWindows::NCOM::CPropVariant property = numPasses; PROPID propID = NCoderPropID::kNumPasses; RINOK(setCoderProperties->SetCoderProperties(&propID, &property, 1)); } RINOK(encoder->Code(fileInStream, outStream, NULL, NULL, localProgress)); return updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK); }
HRESULT CFSDrives::BindToFolderSpec(const wchar_t *name, IFolderFolder **resultFolder) { *resultFolder = 0; if (_volumeMode) return S_OK; NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder; CMyComPtr<IFolderFolder> subFolder = fsFolderSpec; RINOK(fsFolderSpec->Init(name, 0)); *resultFolder = subFolder.Detach(); return S_OK; }
HRESULT CCabFolderOutStream::OpenFile() { Int32 askMode = (*m_ExtractStatuses)[m_CurrentIndex] ? (m_TestMode ? NExtract::NAskMode::kTest : NExtract::NAskMode::kExtract) : NExtract::NAskMode::kSkip; RINOK(m_ExtractCallback->GetStream(m_StartIndex + m_CurrentIndex, &m_RealOutStream, askMode)); if (!m_RealOutStream && !m_TestMode) askMode = NArchive::NExtract::NAskMode::kSkip; return m_ExtractCallback->PrepareOperation(askMode); }
static HRESULT CopyBlock(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress, UInt64 *totalSize = NULL) { NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder; CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec; HRESULT result = copyCoder->Code(inStream, outStream, NULL, NULL, progress); if (totalSize != NULL) *totalSize = copyCoderSpec->TotalSize; return result; }
STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream) { COM_TRY_BEGIN *stream = 0; const CItem &item = _db.Items[_db.Refs[index].Did]; CClusterInStream *streamSpec = new CClusterInStream; CMyComPtr<ISequentialInStream> streamTemp = streamSpec; streamSpec->Stream = _stream; streamSpec->StartOffset = 0; bool isLargeStream = _db.IsLargeStream(item.Size); int bsLog = isLargeStream ? _db.SectorSizeBits : _db.MiniSectorSizeBits; streamSpec->BlockSizeLog = bsLog; streamSpec->Size = item.Size; UInt32 clusterSize = (UInt32)1 << bsLog; UInt64 numClusters64 = (item.Size + clusterSize - 1) >> bsLog; if (numClusters64 >= ((UInt32)1 << 31)) return E_NOTIMPL; streamSpec->Vector.Reserve((int)numClusters64); UInt32 sid = item.Sid; UInt64 size = item.Size; if (size != 0) { for (;; size -= clusterSize) { if (isLargeStream) { if (sid >= _db.FatSize) return S_FALSE; streamSpec->Vector.Add(sid + 1); sid = _db.Fat[sid]; } else { UInt64 val; if (sid >= _db.MatSize || !_db.GetMiniCluster(sid, val) || val >= (UInt64)1 << 32) return S_FALSE; streamSpec->Vector.Add((UInt32)val); sid = _db.Mat[sid]; } if (size <= clusterSize) break; } } if (sid != NFatID::kEndOfChain) return S_FALSE; RINOK(streamSpec->InitAndSeek()); *stream = streamTemp.Detach(); return S_OK; COM_TRY_END }
HRESULT CAgent::CommonUpdate( const wchar_t *newArchiveName, int numUpdateItems, IArchiveUpdateCallback *updateCallback) { if (!CanUpdate()) return E_NOTIMPL; CMyComPtr<IOutArchive> outArchive; RINOK(GetArchive()->QueryInterface(IID_IOutArchive, (void **)&outArchive)); COutFileStream *outStreamSpec = new COutFileStream; CMyComPtr<IOutStream> outStream(outStreamSpec); UString archiveName = newArchiveName; { UString resultPath; int pos; if(!NFile::NDirectory::MyGetFullPathName(archiveName, resultPath, pos)) throw 141716; NFile::NDirectory::CreateComplexDirectory(resultPath.Left(pos)); } /* bool isOK = false; for (int i = 0; i < (1 << 16); i++) { resultName = newArchiveName; if (i > 0) { wchar_t s[32]; ConvertUInt64ToString(i, s); resultName += s; } if (outStreamSpec->Open(realPath)) { isOK = true; break; } if (::GetLastError() != ERROR_FILE_EXISTS) return ::GetLastError(); } if (!isOK) return ::GetLastError(); */ if (!outStreamSpec->Create(archiveName, true)) { // ShowLastErrorMessage(); return E_FAIL; } RINOK(outArchive->UpdateItems(outStream, numUpdateItems, updateCallback)); return outStreamSpec->Close(); }
STDMETHODIMP COutStreamCalcSize::OutStreamFinish() { HRESULT result = S_OK; if (_stream) { CMyComPtr<IOutStreamFinish> outStreamFinish; _stream.QueryInterface(IID_IOutStreamFinish, &outStreamFinish); if (outStreamFinish) result = outStreamFinish->OutStreamFinish(); } return result; }
HRESULT CDecoder::Code(const CHeader &header, ISequentialOutStream *outStream, ICompressProgressInfo *progress) { if (header.FilterID > 1) return E_NOTIMPL; { CMyComPtr<ICompressSetDecoderProperties2> setDecoderProperties; _lzmaDecoder.QueryInterface(IID_ICompressSetDecoderProperties2, &setDecoderProperties); if (!setDecoderProperties) return E_NOTIMPL; RINOK(setDecoderProperties->SetDecoderProperties2(header.LzmaProps, 5)); } CMyComPtr<ICompressSetOutStream> setOutStream; bool filteredMode = (header.FilterID == 1); if (filteredMode) { _bcjStream.QueryInterface(IID_ICompressSetOutStream, &setOutStream); if (!setOutStream) return E_NOTIMPL; RINOK(setOutStream->SetOutStream(outStream)); outStream = _bcjStream; } const UInt64 *Size = header.HasSize() ? &header.Size : NULL; HRESULT res = _lzmaDecoderSpec->CodeResume(outStream, Size, progress); if (filteredMode) { CMyComPtr<IOutStreamFlush> flush; _bcjStream.QueryInterface(IID_IOutStreamFlush, &flush); if (flush) { HRESULT res2 = flush->Flush(); if (res == S_OK) res = res2; } HRESULT res2 = setOutStream->ReleaseOutStream(); if (res == S_OK) res = res2; } RINOK(res); if (header.HasSize()) if (_lzmaDecoderSpec->GetOutputProcessedSize() != header.Size) return S_FALSE; return S_OK; }
STDMETHODIMP CBaseCoder::Init() { CalculateDigest(); if (_aesFilter == 0) { RINOK(CreateFilter()); } CMyComPtr<ICryptoProperties> cp; RINOK(_aesFilter.QueryInterface(IID_ICryptoProperties, &cp)); RINOK(cp->SetKey(_key.Key, sizeof(_key.Key))); RINOK(cp->SetInitVector(_iv, sizeof(_iv))); return S_OK; }
HRESULT CFolderOutStream::Unsupported() { while(m_CurrentIndex < m_ExtractStatuses->Size()) { HRESULT result = OpenFile(); if (result != S_FALSE && result != S_OK) return result; m_RealOutStream.Release(); RINOK(m_ExtractCallback->SetOperationResult(NExtract::NOperationResult::kUnSupportedMethod)); m_CurrentIndex++; } return S_OK; }
HRESULT SetProperties(IUnknown *unknown, const CObjectVector<CProperty> &properties) { if (properties.IsEmpty()) return S_OK; CMyComPtr<ISetProperties> setProperties; unknown->QueryInterface(IID_ISetProperties, (void **)&setProperties); if (!setProperties) return S_OK; UStringVector realNames; CPropVariant *values = new CPropVariant[properties.Size()]; try { int i; for(i = 0; i < properties.Size(); i++) { const CProperty &property = properties[i]; NCOM::CPropVariant propVariant; UString name = property.Name; if (property.Value.IsEmpty()) { if (!name.IsEmpty()) { wchar_t c = name.Back(); if (c == L'-') propVariant = false; else if (c == L'+') propVariant = true; if (propVariant.vt != VT_EMPTY) name.DeleteBack(); } } else ParseNumberString(property.Value, propVariant); realNames.Add(name); values[i] = propVariant; } CRecordVector<const wchar_t *> names; for(i = 0; i < realNames.Size(); i++) names.Add((const wchar_t *)realNames[i]); RINOK(setProperties->SetProperties(&names.Front(), values, names.Size())); } catch(...) { delete []values; throw; } delete []values; return S_OK; }
HRESULT CPlugin::ExtractFiles( bool decompressAllItems, const UInt32 *indices, UInt32 numIndices, bool silent, NExtract::NPathMode::EEnum pathMode, NExtract::NOverwriteMode::EEnum overwriteMode, const UString &destPath, bool passwordIsDefined, const UString &password) { CScreenRestorer screenRestorer; CProgressBox progressBox; CProgressBox *progressBoxPointer = NULL; if (!silent) { screenRestorer.Save(); progressBoxPointer = &progressBox; progressBox.Init( // g_StartupInfo.GetMsgString(NMessageID::kWaitTitle), g_StartupInfo.GetMsgString(NMessageID::kExtracting)); } CExtractCallbackImp *extractCallbackSpec = new CExtractCallbackImp; CMyComPtr<IFolderArchiveExtractCallback> extractCallback(extractCallbackSpec); extractCallbackSpec->Init( CP_OEMCP, progressBoxPointer, /* GetDefaultName(m_FileName, m_ArchiverInfo.Extension), m_FileInfo.MTime, m_FileInfo.Attributes, */ passwordIsDefined, password); if (decompressAllItems) return m_ArchiveHandler->Extract(pathMode, overwriteMode, destPath, BoolToInt(false), extractCallback); else { CMyComPtr<IArchiveFolder> archiveFolder; _folder.QueryInterface(IID_IArchiveFolder, &archiveFolder); return archiveFolder->Extract(indices, numIndices, BoolToInt(true), // includeAltStreams BoolToInt(false), // replaceAltStreamChars pathMode, overwriteMode, destPath, BoolToInt(false), extractCallback); } }
void CPanel::OnTimer() { if (!_processTimer) return; CMyComPtr<IFolderWasChanged> folderWasChanged; if (_folder.QueryInterface(IID_IFolderWasChanged, &folderWasChanged) != S_OK) return; Int32 wasChanged; if (folderWasChanged->WasChanged(&wasChanged) != S_OK) return; if (wasChanged == 0) return; OnReload(); }
static HRESULT WriteRange(IInStream *inStream, ISequentialOutStream *outStream, UInt64 position, UInt64 size, ICompressProgressInfo *progress) { RINOK(inStream->Seek(position, STREAM_SEEK_SET, 0)); CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream; CMyComPtr<CLimitedSequentialInStream> inStreamLimited(streamSpec); streamSpec->SetStream(inStream); streamSpec->Init(size); NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder; CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec; RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress)); return (copyCoderSpec->TotalSize == size ? S_OK : E_FAIL); }
STDMETHODIMP CArchiveFolderManager::OpenFolderFile(IInStream *inStream, const wchar_t *filePath, IFolderFolder **resultFolder, IProgress *progress) { CMyComPtr<IArchiveOpenCallback> openArchiveCallback; if (progress != 0) { CMyComPtr<IProgress> progressWrapper = progress; progressWrapper.QueryInterface(IID_IArchiveOpenCallback, &openArchiveCallback); } CAgent *agent = new CAgent(); CMyComPtr<IInFolderArchive> archive = agent; RINOK(agent->Open(inStream, filePath, NULL, openArchiveCallback)); return agent->BindToRootFolder(resultFolder); }
HRESULT CAgentFolder::BindToFolder(CProxyFolder *folder, IFolderFolder **resultFolder) { CMyComPtr<IFolderFolder> parentFolder; if (folder->Parent != _proxyFolderItem) { RINOK(BindToFolder(folder->Parent, &parentFolder)); } else parentFolder = this; CAgentFolder *folderSpec = new CAgentFolder; CMyComPtr<IFolderFolder> agentFolder = folderSpec; folderSpec->Init(_proxyArchive, folder, parentFolder, _agentSpec); *resultFolder = agentFolder.Detach(); return S_OK; }
static HRESULT SetOutProperties(IOutFolderArchive *outArchive, UINT32 method) { CMyComPtr<ISetProperties> setProperties; if (outArchive->QueryInterface(IID_ISetProperties, (void **)&setProperties) == S_OK) { UStringVector realNames; realNames.Add(UString(L"x")); NCOM::CPropVariant value = (UInt32)method; CRecordVector<const wchar_t *> names; for (int i = 0; i < realNames.Size(); i++) names.Add(realNames[i]); RINOK(setProperties->SetProperties(&names.Front(), &value, names.Size())); } return S_OK; }
HRESULT CCoderMixer2ST::GetOutStream( ISequentialOutStream **outStreams, const UInt64 **outSizes, UInt32 streamIndex, ISequentialOutStream **outStreamRes) { CMyComPtr<ISequentialOutStream> seqOutStream; int i; for(i = 0; i < _bindInfo.OutStreams.Size(); i++) if (_bindInfo.OutStreams[i] == streamIndex) { seqOutStream = outStreams[i]; *outStreamRes = seqOutStream.Detach(); return S_OK; } int binderIndex = _bindInfo.FindBinderForOutStream(streamIndex); if (binderIndex < 0) return E_INVALIDARG; UInt32 coderIndex, coderStreamIndex; _bindInfo.FindInStream(_bindInfo.BindPairs[binderIndex].InIndex, coderIndex, coderStreamIndex); CCoderInfo &coder = _coders[coderIndex]; if (!coder.Coder) return E_NOTIMPL; coder.Coder.QueryInterface(IID_ISequentialOutStream, &seqOutStream); if (!seqOutStream) return E_NOTIMPL; UInt32 startIndex = _bindInfo.GetCoderOutStreamIndex(coderIndex); CMyComPtr<ICompressSetOutStream> setOutStream; if (!coder.Coder) return E_NOTIMPL; coder.Coder.QueryInterface(IID_ICompressSetOutStream, &setOutStream); if (!setOutStream) return E_NOTIMPL; if (coder.NumOutStreams > 1) return E_NOTIMPL; for (i = 0; i < (int)coder.NumOutStreams; i++) { CMyComPtr<ISequentialOutStream> seqOutStream2; RINOK(GetOutStream(outStreams, outSizes, startIndex + i, &seqOutStream2)); RINOK(setOutStream->SetOutStream(seqOutStream2)); } *outStreamRes = seqOutStream.Detach(); return S_OK; }
HRESULT CMtProgressMixer2::SetRatioInfo(unsigned index, const UInt64 *inSize, const UInt64 *outSize) { NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection); if (index == 0 && RatioProgress) { RINOK(RatioProgress->SetRatioInfo(inSize, outSize)); } if (inSize) InSizes[index] = *inSize; if (outSize) OutSizes[index] = *outSize; UInt64 v = ProgressOffset + (_inSizeIsMain ? (InSizes[0] + InSizes[1]) : (OutSizes[0] + OutSizes[1])); return Progress->SetCompleted(&v); }
void CMtProgressMixer2::Create(IProgress *progress, bool inSizeIsMain) { Progress = progress; Progress.QueryInterface(IID_ICompressProgressInfo, &RatioProgress); _inSizeIsMain = inSizeIsMain; ProgressOffset = InSizes[0] = InSizes[1] = OutSizes[0] = OutSizes[1] = 0; }
bool C7ZipArchiveItemImpl::GetFileTimeProperty(lib7zip::PropertyIndexEnum propertyIndex, unsigned __int64 & val) const { int p7zip_index = 0; switch(propertyIndex) { case lib7zip::kpidCTime: //(Created) p7zip_index = kpidCTime; break; case lib7zip::kpidATime: //(Accessed) p7zip_index = kpidATime; break; case lib7zip::kpidMTime: //(Modified) p7zip_index = kpidMTime; break; default: return false; } NWindows::NCOM::CPropVariant prop; if (m_pInArchive->GetProperty(m_nIndex, p7zip_index, &prop) != 0) return false; if (prop.vt == VT_FILETIME) { unsigned __int64 tmp_val = 0; memmove(&tmp_val, &prop.filetime, sizeof(unsigned __int64)); val = tmp_val; return true; } return false; }
STDAPI CreateObject( const GUID *classID, const GUID *interfaceID, void **outObject) { COM_TRY_BEGIN *outObject = 0; if (*classID != CLSID_CCabHandler) return CLASS_E_CLASSNOTAVAILABLE; if (*interfaceID != IID_IInArchive) return E_NOINTERFACE; CMyComPtr<IInArchive> inArchive = (IInArchive *)new NArchive::NCab::CHandler; *outObject = inArchive.Detach(); COM_TRY_END return S_OK; }
void BitMemExtractor::extract( const vector< byte_t >& in_buffer, vector< byte_t >& out_buffer, unsigned int index ) const { CMyComPtr< IInArchive > inArchive = openArchive( mLibrary, mFormat, in_buffer, *this ); NCOM::CPropVariant prop; inArchive->GetProperty( index, kpidSize, &prop ); MemExtractCallback* extractCallbackSpec = new MemExtractCallback( *this, inArchive, out_buffer ); const UInt32 indices[] = { index }; CMyComPtr< IArchiveExtractCallback > extractCallback( extractCallbackSpec ); if ( inArchive->Extract( indices, 1, false, extractCallback ) != S_OK ) { throw BitException( extractCallbackSpec->getErrorMessage() ); } }