zipcentraldir.cpp

ZIP压缩、解压缩算法库

	}
	m_info.m_bOnDisk = true;
}

void CZipCentralDir::WriteHeaders(CZipActionCallback* pCallback, bool bOneDisk)
{
	m_info.m_uDiskEntriesNo = 0;
	m_info.m_uDiskWithCD = (WORD)m_pStorage->GetCurrentDisk();
	m_info.m_uOffset = m_pStorage->GetPosition() - m_info.m_uBytesBeforeZip;
	if (!m_info.m_uEntriesNumber)
		return;

	WORD iDisk = m_info.m_uDiskWithCD;
	int iStep = 0; // for the compiler

	if (pCallback)
	{
		pCallback->Init();
		pCallback->SetTotal(m_info.m_uEntriesNumber);
		iStep = CZipActionCallback::m_iStep;// we don't want to wait forever
	}

	int iAborted = 0;
	for (int i = 0; i < m_info.m_uEntriesNumber; i++)
	{
		CZipFileHeader* pHeader = (*this)[i];
		

		CZipString szRemember;
		if (m_bConvertAfterOpen)
			// if CZipArchive::Flush is called we will be still using the archive, so restore changed name
			szRemember = pHeader->GetFileName();

		ConvertFileName(false, true, pHeader);
		m_info.m_uSize += pHeader->Write(m_pStorage);

		if (m_bConvertAfterOpen)
			pHeader->SetFileName(szRemember);

		if (m_pStorage->GetCurrentDisk() != iDisk)
		{
			m_info.m_uDiskEntriesNo = 1;
			iDisk = (WORD)m_pStorage->GetCurrentDisk();
			// update the information about the offset and starting disk if the 
			// first header was written on the new disk
			if (i == 0)
			{
				m_info.m_uOffset = 0;
				m_info.m_uDiskWithCD = iDisk;
			}
		}
		else 
			m_info.m_uDiskEntriesNo++;
		if (pCallback && !(i%iStep))
			if (!pCallback->Callback(iStep))
			{
				
				if (bOneDisk) 
				{
					if (!m_pStorage->IsSpanMode())
						m_pStorage->EmptyWriteBuffer();
					else
						m_pStorage->Flush(); // must be flush before - flush was not called in span mode
					
					// remove saved part from the disk
					m_pStorage->m_pFile->SetLength(m_info.m_uBytesBeforeZip + m_info.m_uOffset);
//	 				We can now abort safely
					iAborted = CZipException::abortedSafely;
				}
				else
					iAborted = CZipException::abortedAction;
				break;
			}
	}

	if (pCallback)
		pCallback->CallbackEnd();

	if (iAborted)
		ThrowError(iAborted);
}

DWORD CZipCentralDir::WriteCentralEnd()
{
	DWORD uSize = GetSize();
	CZipAutoBuffer buf(uSize);
	WORD uCommentSize = (WORD)m_pszComment.GetSize();
	memcpy(buf, m_gszSignature, 4);
	memcpy(buf + 4, &m_info.m_uThisDisk, 2);
	memcpy(buf + 6, &m_info.m_uDiskWithCD, 2);
	memcpy(buf + 8, &m_info.m_uDiskEntriesNo, 2);
	memcpy(buf + 10, &m_info.m_uEntriesNumber, 2);
	memcpy(buf + 12, &m_info.m_uSize, 4);
	memcpy(buf + 16, &m_info.m_uOffset, 4);
	memcpy(buf + 20, &uCommentSize, 2);
	memcpy(buf + 22, m_pszComment, uCommentSize);
	m_pStorage->Write(buf, uSize, true);
	return uSize;
}

void CZipCentralDir::RemoveAll()
{
	m_findarray.RemoveAll();
	RemoveHeaders();
}

void CZipCentralDir::RemoveFile(CZipFileHeader* pHeader, int iIndex, bool bShift)
{

	if (iIndex == -1)
	{
		int iCount = m_headers.GetSize();
		for (int i = 0; i < iCount; i++)
			if (pHeader == m_headers[i])
			{
				iIndex = i;
				break;
			}
	}
	ASSERT(iIndex != -1 || pHeader);
	if (!pHeader)
		pHeader = m_headers[iIndex];

	if (m_bFindFastEnabled)
	{
		int i = FindFileNameIndex(pHeader->GetFileName());
		ASSERT(i != -1);
		int uIndex = m_findarray[i].m_uIndex;
		m_findarray.RemoveAt(i);
		// shift down the indexes
		
		if (bShift)
		{
			int iSize = m_findarray.GetSize();
			for (int j = 0; j < iSize; j++)
			{
				if (m_findarray[j].m_uIndex > uIndex)
					m_findarray[j].m_uIndex--;
			}
		}
	}


	
	if (iIndex != -1)
	{
		delete pHeader;
		m_headers.RemoveAt(iIndex);
	}
	
}


DWORD CZipCentralDir::GetSize(bool bWhole) const
{
	DWORD uHeaders = 0;
	int iCount = m_headers.GetSize();
	if (bWhole)
	{
		for (int i = 0; i < iCount; i++)
		{
			const CZipFileHeader* pHeader = m_headers[i];
			uHeaders += pHeader->GetSize();
		}
	}
	return CENTRALDIRSIZE + m_pszComment.GetSize() + uHeaders;
}

bool CZipCentralDir::RemoveDataDescr(bool bFromBuffer)
{
	ziparchv::CZipFileMapping fm;
	char* pFile;
	DWORD uSize;
	if (bFromBuffer)
	{
		uSize = m_pStorage->m_uBytesInWriteBuffer;
		pFile = m_pStorage->m_pWriteBuffer;
	}
	else
	{
		uSize = m_pStorage->m_pFile->GetLength();
		// we cannot use CZipMemFile in multidisk archive
		// so it MUST be CZipFile
		if (!fm.CreateMapping(static_cast<CZipFile*>(m_pStorage->m_pFile)))
			return false;
		pFile = fm.GetMappedMemory();
	}

	DWORD uOffsetToChange = 4;
	DWORD uPosInBuffer = 0;
	DWORD uExtraHeaderLen;
	int iCount = m_headers.GetSize();
	for (int i = 0; i < iCount; i++)
	{
		// update the flag value in the local and central header
// 		int uDataDescr = (m_headers[i]->m_uFlag & 8) ? (4 + 12) : 0;

		CZipFileHeader* pHeader = m_headers[i];


		char* pSour = pFile + pHeader->m_uOffset;
		
		if (!pHeader->IsEncrypted())
		{
			// removing data descriptor
			pHeader->m_uFlag &= ~8;
			// update local header:
			// write modified flag in the local header
			memcpy(pSour + 6, &pHeader->m_uFlag, 2);
			uExtraHeaderLen = 4/*ext. header signature*/ + 12/*data descriptor*/;
		}
		else
			// do not remove data descriptors from encrypted files
			uExtraHeaderLen = 0;

		// update crc32 and sizes' values
		pHeader->GetCrcAndSizes(pSour+ 14);

		DWORD uToCopy = (i == (iCount - 1) ? uSize : m_headers[i + 1]->m_uOffset)
			- pHeader->m_uOffset - uExtraHeaderLen;

		memmove(pFile + uPosInBuffer, pSour, uToCopy);

		uPosInBuffer += uToCopy;
		pHeader->m_uOffset -= uOffsetToChange;
		uOffsetToChange += uExtraHeaderLen;
	}

	if (bFromBuffer)
		m_pStorage->m_uBytesInWriteBuffer = uPosInBuffer;
	else
	{
		m_pStorage->m_iBytesWritten = uPosInBuffer;
		fm.RemoveMapping();
		m_pStorage->m_pFile->SetLength(uPosInBuffer);
	}
	return true;
}

void CZipCentralDir::RemoveHeaders()
{
	int iCount = m_headers.GetSize();
	for (int i = 0; i < iCount; i++)
		delete m_headers[i];
	m_headers.RemoveAll();
}



void CZipCentralDir::ConvertAll()
{
	ASSERT(!m_bConvertAfterOpen);
	int iCount = m_headers.GetSize();
	for (int i = 0; i < iCount; i++)
		ConvertFileName(true, false, m_headers[i]);
	m_bConvertAfterOpen = true;
}

void CZipCentralDir::BuildFindFastArray( bool bCaseSensitive )
{
	m_findarray.RemoveAll();
	m_bCaseSensitive = bCaseSensitive;
	m_pCompare = GetCZipStrCompFunc(bCaseSensitive);
	int iCount = m_headers.GetSize();
	if (!m_bConvertAfterOpen)
	{
		for (int i = 0; i < iCount; i++)
		{
			CZipFileHeader fh = *m_headers[i];
			ConvertFileName(true, false, &fh);
			InsertFindFastElement(&fh, i); // this method requires the name to be already converted
		}
	}
	else
		for (int i = 0; i < iCount; i++)
			InsertFindFastElement(m_headers[i], i);
}

void CZipCentralDir::EnableFindFast(bool bEnable, bool bCaseSensitive)
{
	if (m_bFindFastEnabled == bEnable)
		return;
	m_bFindFastEnabled = bEnable;
	if (bEnable)
		BuildFindFastArray(bCaseSensitive);
	else
		m_findarray.RemoveAll();
}

int CZipCentralDir::FindFile(LPCTSTR lpszFileName, bool bCaseSensitive, bool bSporadically, bool bFileNameOnly)
{
	// this is required for fast finding and is done only once
	if (!m_bConvertAfterOpen)
	{
		TRACE(_T("%s(%i) : Converting all the filenames.\n"),__FILE__,__LINE__);
		ConvertAll();
	}
	if (!m_bFindFastEnabled)
		EnableFindFast(true, bSporadically ? !bCaseSensitive : bCaseSensitive);
	int iResult = -1;
	if (bFileNameOnly)
	{
		//  a non-effective search (treat an array as unsorted)

		// set the proper compare function
		if (bCaseSensitive != m_bCaseSensitive)
			m_pCompare = GetCZipStrCompFunc(bCaseSensitive);

		int iSize = m_findarray.GetSize();
		for (int i = 0; i < iSize; i++)
		{
			CZipString sz = GetProperHeaderFileName(m_findarray[i].m_pHeader);
			CZipPathComponent::RemoveSeparators(sz); // to find a dir
			CZipPathComponent zpc(sz);
			sz = zpc.GetFileName();
			if ((sz.*m_pCompare)(lpszFileName) == 0)
			{
				iResult = i;
				break;
			}
		}

		// restore the compare function
		if (bCaseSensitive != m_bCaseSensitive)
			m_pCompare = GetCZipStrCompFunc(!bCaseSensitive);
	}
	else if (bCaseSensitive == m_bCaseSensitive)
		iResult = FindFileNameIndex(lpszFileName);
	else
	{
		if (bSporadically)
		{
			//  a non-effective search (treat an array as unsorted)

			m_pCompare = GetCZipStrCompFunc(bCaseSensitive);			
			int iSize = m_findarray.GetSize();
			for (int i = 0; i < iSize; i++)
				if (CompareElement(lpszFileName, (WORD)i) == 0)
				{
					iResult = i;
					break;
				}
			m_pCompare = GetCZipStrCompFunc(!bCaseSensitive);
		}
		else
		{
			BuildFindFastArray(bCaseSensitive);		
			iResult = FindFileNameIndex(lpszFileName);
		}
	}
	return iResult == -1 ? -1 : m_findarray[iResult].m_uIndex;	
}

void CZipCentralDir::InsertFindFastElement(CZipFileHeader* pHeader, WORD uIndex)
{
	CZipString fileName = pHeader->GetFileName();
	int iSize = m_findarray.GetSize();

	//	Our initial binary search range encompasses the entire array of filenames:
	int start = 0;
	int end = iSize;

	//	Keep halving our search range until we find the right place
	//	to insert the new element:
	while ( start < end )
	{
		//	Find the midpoint of the search range:
		int midpoint = ( start + end ) / 2;

		//	Compare the filename with the filename at the midpoint of the current search range:
		int result = CompareElement(fileName, (WORD)midpoint);

		//	If our filename is larger, it must fall in the first half of the search range:
		if ( result > 0 )
		{
			end = midpoint;
		}

		//	If it's smaller, it must fall in the last half:
		else if ( result < 0 )
		{
			start = midpoint + 1;
		}

		//	If they're equal, we can go ahead and insert here:
		else
		{
			start = midpoint; break;
		}
	}
	m_findarray.InsertAt(start, CZipFindFast(pHeader, WORD(uIndex == WORD(-1) ? iSize : uIndex /* just in case */))); 
}

int CZipCentralDir::FindFileNameIndex(LPCTSTR lpszFileName) const
{
	int start = 0;
	int end = m_findarray.GetUpperBound();

	//	Keep halving our search range until we find the given element:
	while ( start <= end )
	{
		//	Find the midpoint of the search range:
		int midpoint = ( start + end ) / 2;

		//	Compare the given filename with the filename at the midpoint of the search range:
		int result = CompareElement(lpszFileName, (WORD)midpoint);

		//	If our filename is smaller, it must fall in the first half of the search range:
		if ( result > 0 )
		{
			end = midpoint - 1;
		}

		//	If it's larger, it must fall in the last half:
		else if ( result < 0 )
		{
			start = midpoint + 1;
		}

		//	If they're equal, return the result:
		else
		{
			return midpoint;
		}
	}

	//	Signal failure:
	return -1;
}

void CZipCentralDir::RenameFile(WORD uIndex, LPCTSTR lpszNewName)
{
	CZipFileHeader* pHeader = m_headers[uIndex];
	pHeader->SetFileName(lpszNewName);
	if (!m_bConvertAfterOpen)
		ZipCompatibility::FileNameUpdate(*pHeader, false, m_bOemConversion);
	if (m_bFindFastEnabled)
		BuildFindFastArray(m_bCaseSensitive);
}