/*****************************************************************************/ /* SFilePatchArchives.cpp Copyright (c) Ladislav Zezula 2010 */ /*---------------------------------------------------------------------------*/ /* Description: */ /*---------------------------------------------------------------------------*/ /* Date Ver Who Comment */ /* -------- ---- --- ------- */ /* 18.08.10 1.00 Lad The first version of SFilePatchArchives.cpp */ /*****************************************************************************/ #define __STORMLIB_SELF__ #include "StormLib.h" #include "StormCommon.h" //----------------------------------------------------------------------------- // Local structures #define MAX_SC2_PATCH_PREFIX 0x80 #define PATCH_SIGNATURE_HEADER 0x48435450 #define PATCH_SIGNATURE_MD5 0x5f35444d #define PATCH_SIGNATURE_XFRM 0x4d524658 #define SIZE_OF_XFRM_HEADER 0x0C // Header for incremental patch files typedef struct _MPQ_PATCH_HEADER { //-- PATCH header ----------------------------------- DWORD dwSignature; // 'PTCH' DWORD dwSizeOfPatchData; // Size of the entire patch (decompressed) DWORD dwSizeBeforePatch; // Size of the file before patch DWORD dwSizeAfterPatch; // Size of file after patch //-- MD5 block -------------------------------------- DWORD dwMD5; // 'MD5_' DWORD dwMd5BlockSize; // Size of the MD5 block, including the signature and size itself BYTE md5_before_patch[0x10]; // MD5 of the original (unpached) file BYTE md5_after_patch[0x10]; // MD5 of the patched file //-- XFRM block ------------------------------------- DWORD dwXFRM; // 'XFRM' DWORD dwXfrmBlockSize; // Size of the XFRM block, includes XFRM header and patch data DWORD dwPatchType; // Type of patch ('BSD0' or 'COPY') // Followed by the patch data } MPQ_PATCH_HEADER, *PMPQ_PATCH_HEADER; typedef struct _BLIZZARD_BSDIFF40_FILE { ULONGLONG Signature; ULONGLONG CtrlBlockSize; ULONGLONG DataBlockSize; ULONGLONG NewFileSize; } BLIZZARD_BSDIFF40_FILE, *PBLIZZARD_BSDIFF40_FILE; typedef struct _BSDIFF_CTRL_BLOCK { DWORD dwAddDataLength; DWORD dwMovDataLength; DWORD dwOldMoveLength; } BSDIFF_CTRL_BLOCK, *PBSDIFF_CTRL_BLOCK; typedef struct _LOCALIZED_MPQ_INFO { const char * szNameTemplate; // Name template size_t nLangOffset; // Offset of the language size_t nLength; // Length of the name template } LOCALIZED_MPQ_INFO, *PLOCALIZED_MPQ_INFO; //----------------------------------------------------------------------------- // Local variables // 4-byte groups for all languages static const char * LanguageList = "baseteenenUSenGBenCNenTWdeDEesESesMXfrFRitITkoKRptBRptPTruRUzhCNzhTW"; // List of localized MPQs for World of Warcraft static LOCALIZED_MPQ_INFO LocaleMpqs_WoW[] = { {"expansion1-locale-####", 18, 22}, {"expansion1-speech-####", 18, 22}, {"expansion2-locale-####", 18, 22}, {"expansion2-speech-####", 18, 22}, {"expansion3-locale-####", 18, 22}, {"expansion3-speech-####", 18, 22}, {"locale-####", 7, 11}, {"speech-####", 7, 11}, {NULL, 0, 0} }; //----------------------------------------------------------------------------- // Local functions static inline bool IsPatchMetadataFile(TFileEntry * pFileEntry) { // The file must ave a name if(pFileEntry->szFileName != NULL && (pFileEntry->dwFlags & MPQ_FILE_PATCH_FILE) == 0) { // The file must be small if(0 < pFileEntry->dwFileSize && pFileEntry->dwFileSize < 0x40) { // Compare the plain name return (_stricmp(GetPlainFileName(pFileEntry->szFileName), PATCH_METADATA_NAME) == 0); } } // Not a patch_metadata return false; } static void Decompress_RLE(LPBYTE pbDecompressed, DWORD cbDecompressed, LPBYTE pbCompressed, DWORD cbCompressed) { LPBYTE pbDecompressedEnd = pbDecompressed + cbDecompressed; LPBYTE pbCompressedEnd = pbCompressed + cbCompressed; BYTE RepeatCount; BYTE OneByte; // Cut the initial DWORD from the compressed chunk pbCompressed += sizeof(DWORD); // Pre-fill decompressed buffer with zeros memset(pbDecompressed, 0, cbDecompressed); // Unpack while(pbCompressed < pbCompressedEnd && pbDecompressed < pbDecompressedEnd) { OneByte = *pbCompressed++; // Is it a repetition byte ? if(OneByte & 0x80) { RepeatCount = (OneByte & 0x7F) + 1; for(BYTE i = 0; i < RepeatCount; i++) { if(pbDecompressed == pbDecompressedEnd || pbCompressed == pbCompressedEnd) break; *pbDecompressed++ = *pbCompressed++; } } else { pbDecompressed += (OneByte + 1); } } } static DWORD LoadFilePatch_COPY(TMPQFile * hf, PMPQ_PATCH_HEADER pFullPatch) { DWORD cbBytesToRead = pFullPatch->dwSizeOfPatchData - sizeof(MPQ_PATCH_HEADER); DWORD cbBytesRead = 0; // Simply load the rest of the patch SFileReadFile((HANDLE)hf, (pFullPatch + 1), cbBytesToRead, &cbBytesRead, NULL); return (cbBytesRead == cbBytesToRead) ? ERROR_SUCCESS : ERROR_FILE_CORRUPT; } static DWORD LoadFilePatch_BSD0(TMPQFile * hf, PMPQ_PATCH_HEADER pFullPatch) { LPBYTE pbDecompressed = (LPBYTE)(pFullPatch + 1); LPBYTE pbCompressed = NULL; DWORD cbDecompressed = 0; DWORD cbCompressed = 0; DWORD dwBytesRead = 0; DWORD dwErrCode = ERROR_SUCCESS; // Calculate the size of compressed data cbDecompressed = pFullPatch->dwSizeOfPatchData - sizeof(MPQ_PATCH_HEADER); cbCompressed = pFullPatch->dwXfrmBlockSize - SIZE_OF_XFRM_HEADER; // Is that file compressed? if(cbCompressed < cbDecompressed) { pbCompressed = STORM_ALLOC(BYTE, cbCompressed); if(pbCompressed == NULL) dwErrCode = ERROR_NOT_ENOUGH_MEMORY; // Read the compressed patch data if(dwErrCode == ERROR_SUCCESS) { SFileReadFile((HANDLE)hf, pbCompressed, cbCompressed, &dwBytesRead, NULL); if(dwBytesRead != cbCompressed) dwErrCode = ERROR_FILE_CORRUPT; } // Decompress the data if(dwErrCode == ERROR_SUCCESS) Decompress_RLE(pbDecompressed, cbDecompressed, pbCompressed, cbCompressed); if(pbCompressed != NULL) STORM_FREE(pbCompressed); } else { SFileReadFile((HANDLE)hf, pbDecompressed, cbDecompressed, &dwBytesRead, NULL); if(dwBytesRead != cbDecompressed) dwErrCode = ERROR_FILE_CORRUPT; } return dwErrCode; } static DWORD ApplyFilePatch_COPY( TMPQPatcher * pPatcher, PMPQ_PATCH_HEADER pFullPatch, LPBYTE pbTarget, LPBYTE pbSource) { // Sanity checks assert(pPatcher->cbMaxFileData >= pPatcher->cbFileData); pFullPatch = pFullPatch; // Copy the patch data as-is memcpy(pbTarget, pbSource, pPatcher->cbFileData); return ERROR_SUCCESS; } static DWORD ApplyFilePatch_BSD0( TMPQPatcher * pPatcher, PMPQ_PATCH_HEADER pFullPatch, LPBYTE pbTarget, LPBYTE pbSource) { PBLIZZARD_BSDIFF40_FILE pBsdiff; PBSDIFF_CTRL_BLOCK pCtrlBlock; LPBYTE pbPatchData = (LPBYTE)(pFullPatch + 1); LPBYTE pDataBlock; LPBYTE pExtraBlock; LPBYTE pbOldData = pbSource; LPBYTE pbNewData = pbTarget; DWORD dwCombineSize; DWORD dwNewOffset = 0; // Current position to patch DWORD dwOldOffset = 0; // Current source position DWORD dwNewSize; // Patched file size DWORD dwOldSize = pPatcher->cbFileData; // File size before patch // Get pointer to the patch header // Format of BSDIFF header corresponds to original BSDIFF, which is: // 0000 8 bytes signature "BSDIFF40" // 0008 8 bytes size of the control block // 0010 8 bytes size of the data block // 0018 8 bytes new size of the patched file pBsdiff = (PBLIZZARD_BSDIFF40_FILE)pbPatchData; pbPatchData += sizeof(BLIZZARD_BSDIFF40_FILE); // Get pointer to the 32-bit BSDIFF control block // The control block follows immediately after the BSDIFF header // and consists of three 32-bit integers // 0000 4 bytes Length to copy from the BSDIFF data block the new file // 0004 4 bytes Length to copy from the BSDIFF extra block // 0008 4 bytes Size to increment source file offset pCtrlBlock = (PBSDIFF_CTRL_BLOCK)pbPatchData; pbPatchData += (size_t)BSWAP_INT64_UNSIGNED(pBsdiff->CtrlBlockSize); // Get the pointer to the data block pDataBlock = (LPBYTE)pbPatchData; pbPatchData += (size_t)BSWAP_INT64_UNSIGNED(pBsdiff->DataBlockSize); // Get the pointer to the extra block pExtraBlock = (LPBYTE)pbPatchData; dwNewSize = (DWORD)BSWAP_INT64_UNSIGNED(pBsdiff->NewFileSize); // Now patch the file while(dwNewOffset < dwNewSize) { DWORD dwAddDataLength = BSWAP_INT32_UNSIGNED(pCtrlBlock->dwAddDataLength); DWORD dwMovDataLength = BSWAP_INT32_UNSIGNED(pCtrlBlock->dwMovDataLength); DWORD dwOldMoveLength = BSWAP_INT32_UNSIGNED(pCtrlBlock->dwOldMoveLength); DWORD i; // Sanity check if((dwNewOffset + dwAddDataLength) > dwNewSize) return ERROR_FILE_CORRUPT; // Read the diff string to the target buffer memcpy(pbNewData + dwNewOffset, pDataBlock, dwAddDataLength); pDataBlock += dwAddDataLength; // Get the longest block that we can combine dwCombineSize = ((dwOldOffset + dwAddDataLength) >= dwOldSize) ? (dwOldSize - dwOldOffset) : dwAddDataLength; if((dwNewOffset + dwCombineSize) > dwNewSize || (dwNewOffset + dwCombineSize) < dwNewOffset) return ERROR_FILE_CORRUPT; // Now combine the patch data with the original file for(i = 0; i < dwCombineSize; i++) pbNewData[dwNewOffset + i] = pbNewData[dwNewOffset + i] + pbOldData[dwOldOffset + i]; // Move the offsets dwNewOffset += dwAddDataLength; dwOldOffset += dwAddDataLength; // Sanity check if((dwNewOffset + dwMovDataLength) > dwNewSize) return ERROR_FILE_CORRUPT; // Copy the data from the extra block in BSDIFF patch memcpy(pbNewData + dwNewOffset, pExtraBlock, dwMovDataLength); pExtraBlock += dwMovDataLength; dwNewOffset += dwMovDataLength; // Move the old offset if(dwOldMoveLength & 0x80000000) dwOldMoveLength = 0x80000000 - dwOldMoveLength; dwOldOffset += dwOldMoveLength; pCtrlBlock++; } // The size after patch must match if(dwNewOffset != pFullPatch->dwSizeAfterPatch) return ERROR_FILE_CORRUPT; // Update the new data size pPatcher->cbFileData = dwNewOffset; return ERROR_SUCCESS; } static PMPQ_PATCH_HEADER LoadFullFilePatch(TMPQFile * hf, MPQ_PATCH_HEADER & PatchHeader) { PMPQ_PATCH_HEADER pFullPatch; DWORD dwErrCode = ERROR_SUCCESS; // BSWAP the entire header, if needed BSWAP_ARRAY32_UNSIGNED(&PatchHeader, sizeof(DWORD) * 6); BSWAP_ARRAY32_UNSIGNED(&PatchHeader.dwXFRM, sizeof(DWORD) * 3); // Verify the signatures in the patch header if(PatchHeader.dwSignature != PATCH_SIGNATURE_HEADER || PatchHeader.dwMD5 != PATCH_SIGNATURE_MD5 || PatchHeader.dwXFRM != PATCH_SIGNATURE_XFRM) return NULL; // Allocate space for patch header and compressed data pFullPatch = (PMPQ_PATCH_HEADER)STORM_ALLOC(BYTE, PatchHeader.dwSizeOfPatchData); if(pFullPatch != NULL) { // Copy the patch header memcpy(pFullPatch, &PatchHeader, sizeof(MPQ_PATCH_HEADER)); // Read the patch, depending on patch type if(dwErrCode == ERROR_SUCCESS) { switch(PatchHeader.dwPatchType) { case 0x59504f43: // 'COPY' dwErrCode = LoadFilePatch_COPY(hf, pFullPatch); break; case 0x30445342: // 'BSD0' dwErrCode = LoadFilePatch_BSD0(hf, pFullPatch); break; default: dwErrCode = ERROR_FILE_CORRUPT; break; } } // If something failed, free the patch buffer if(dwErrCode != ERROR_SUCCESS) { STORM_FREE(pFullPatch); pFullPatch = NULL; } } // Give the result to the caller return pFullPatch; } static DWORD ApplyFilePatch( TMPQPatcher * pPatcher, PMPQ_PATCH_HEADER pFullPatch) { LPBYTE pbSource = (pPatcher->nCounter & 0x1) ? pPatcher->pbFileData2 : pPatcher->pbFileData1; LPBYTE pbTarget = (pPatcher->nCounter & 0x1) ? pPatcher->pbFileData1 : pPatcher->pbFileData2; DWORD dwErrCode; // Sanity checks assert(pFullPatch->dwSizeAfterPatch <= pPatcher->cbMaxFileData); // Apply the patch according to the type switch(pFullPatch->dwPatchType) { case 0x59504f43: // 'COPY' dwErrCode = ApplyFilePatch_COPY(pPatcher, pFullPatch, pbTarget, pbSource); break; case 0x30445342: // 'BSD0' dwErrCode = ApplyFilePatch_BSD0(pPatcher, pFullPatch, pbTarget, pbSource); break; default: dwErrCode = ERROR_FILE_CORRUPT; break; } // Verify MD5 after patch if(dwErrCode == ERROR_SUCCESS && pFullPatch->dwSizeAfterPatch != 0) { // Verify the patched file if(!VerifyDataBlockHash(pbTarget, pFullPatch->dwSizeAfterPatch, pFullPatch->md5_after_patch)) dwErrCode = ERROR_FILE_CORRUPT; // Copy the MD5 of the new block memcpy(pPatcher->this_md5, pFullPatch->md5_after_patch, MD5_DIGEST_SIZE); } return dwErrCode; } //----------------------------------------------------------------------------- // Local functions (patch prefix matching) static bool CreatePatchPrefix(TMPQArchive * ha, const char * szFileName, size_t nLength) { TMPQNamePrefix * pNewPrefix; // If the length of the patch prefix was not entered, find it // Not that the patch prefix must always begin with backslash if(szFileName != NULL && nLength == 0) nLength = strlen(szFileName); // Create the patch prefix pNewPrefix = (TMPQNamePrefix *)STORM_ALLOC(BYTE, sizeof(TMPQNamePrefix) + nLength + 1); if(pNewPrefix != NULL) { // Fill the name prefix. Also add the backslash if(szFileName && nLength) { memcpy(pNewPrefix->szPatchPrefix, szFileName, nLength); if(pNewPrefix->szPatchPrefix[nLength - 1] != '\\') pNewPrefix->szPatchPrefix[nLength++] = '\\'; } // Terminate the string and fill the length pNewPrefix->szPatchPrefix[nLength] = 0; pNewPrefix->nLength = nLength; } ha->pPatchPrefix = pNewPrefix; return (pNewPrefix != NULL); } static bool CheckAndCreatePatchPrefix(TMPQArchive * ha, const char * szPatchPrefix, size_t nLength) { char szTempName[MAX_SC2_PATCH_PREFIX + 0x41]; bool bResult = false; // Prepare the patch file name if(nLength > MAX_SC2_PATCH_PREFIX) return false; // Prepare the patched file name memcpy(szTempName, szPatchPrefix, nLength); memcpy(&szTempName[nLength], "\\(patch_metadata)", 18); // Verifywhether that file exists if(GetFileEntryLocale(ha, szTempName, 0) != NULL) bResult = CreatePatchPrefix(ha, szPatchPrefix, nLength); return bResult; } static bool IsMatchingPatchFile( TMPQArchive * ha, const char * szFileName, LPBYTE pbBaseFileMd5) { MPQ_PATCH_HEADER PatchHeader = {0}; HANDLE hFile = NULL; DWORD dwTransferred = 0; DWORD dwFlags = 0; bool bResult = false; // Open the file and load the patch header if(SFileOpenFileEx((HANDLE)ha, szFileName, SFILE_OPEN_BASE_FILE, &hFile)) { // Retrieve the flags. We need to know whether the file is a patch or not SFileGetFileInfo(hFile, SFileInfoFlags, &dwFlags, sizeof(DWORD), &dwTransferred); if(dwFlags & MPQ_FILE_PATCH_FILE) { // Load the patch header SFileReadFile(hFile, &PatchHeader, sizeof(MPQ_PATCH_HEADER), &dwTransferred, NULL); BSWAP_ARRAY32_UNSIGNED(&PatchHeader, sizeof(DWORD) * 6); // If the file contains an incremental patch, // compare the "MD5 before patching" with the base file MD5 if(dwTransferred == sizeof(MPQ_PATCH_HEADER) && PatchHeader.dwSignature == PATCH_SIGNATURE_HEADER) bResult = (!memcmp(PatchHeader.md5_before_patch, pbBaseFileMd5, MD5_DIGEST_SIZE)); } else { // TODO: How to match it if it's not an incremental patch? // Example: StarCraft II\Updates\enGB\s2-update-enGB-23258.MPQ: // Mods\Core.SC2Mod\enGB.SC2Assets\StreamingBuckets.txt" bResult = false; } // Close the file SFileCloseFile(hFile); } return bResult; } static const char * FindArchiveLanguage(TMPQArchive * ha, PLOCALIZED_MPQ_INFO pMpqInfo) { TFileEntry * pFileEntry; const char * szLanguage = LanguageList; char szFileName[0x40]; // Iterate through all localized languages while(pMpqInfo->szNameTemplate != NULL) { // Iterate through all languages for(szLanguage = LanguageList; szLanguage[0] != 0; szLanguage += 4) { // Construct the file name memcpy(szFileName, pMpqInfo->szNameTemplate, pMpqInfo->nLength); szFileName[pMpqInfo->nLangOffset + 0] = szLanguage[0]; szFileName[pMpqInfo->nLangOffset + 1] = szLanguage[1]; szFileName[pMpqInfo->nLangOffset + 2] = szLanguage[2]; szFileName[pMpqInfo->nLangOffset + 3] = szLanguage[3]; // Append the suffix memcpy(szFileName + pMpqInfo->nLength, "-md5.lst", 9); // Check whether the name exists pFileEntry = GetFileEntryLocale(ha, szFileName, 0); if(pFileEntry != NULL) return szLanguage; } // Move to the next language name pMpqInfo++; } // Not found return NULL; } //----------------------------------------------------------------------------- // Finding ratch prefix for an temporary build of WoW (Pre-Cataclysm) static bool FindPatchPrefix_WoW_13164_13623(TMPQArchive * haBase, TMPQArchive * haPatch) { const char * szPatchPrefix; char szNamePrefix[0x08]; // Try to find the language of the MPQ archive szPatchPrefix = FindArchiveLanguage(haBase, LocaleMpqs_WoW); if(szPatchPrefix == NULL) szPatchPrefix = "Base"; // Format the patch prefix szNamePrefix[0] = szPatchPrefix[0]; szNamePrefix[1] = szPatchPrefix[1]; szNamePrefix[2] = szPatchPrefix[2]; szNamePrefix[3] = szPatchPrefix[3]; szNamePrefix[4] = '\\'; szNamePrefix[5] = 0; return CreatePatchPrefix(haPatch, szNamePrefix, 5); } //----------------------------------------------------------------------------- // Finding patch prefix for Starcraft II (Pre-Legacy of the Void) // // This method tries to match the patch by placement of the archive (in the game subdirectory) // // Archive Path: %GAME_DIR%\Mods\SwarmMulti.SC2Mod\Base.SC2Data // Patch Prefix: Mods\SwarmMulti.SC2Mod\Base.SC2Data // // Archive Path: %ANY_DIR%\MPQ_2013_v4_Mods#Liberty.SC2Mod#enGB.SC2Data // Patch Prefix: Mods\Liberty.SC2Mod\enGB.SC2Data // static bool CheckPatchPrefix_SC2_ArchiveName( TMPQArchive * haPatch, const TCHAR * szPathPtr, const TCHAR * szSeparator, const TCHAR * szPathEnd, const TCHAR * szExpectedString, size_t cchExpectedString) { char szPatchPrefix[MAX_SC2_PATCH_PREFIX+0x41]; size_t nLength = 0; bool bResult = false; // Check whether the length is equal to the length of the expected string if((size_t)(szSeparator - szPathPtr) == cchExpectedString) { // Now check the string itself if(!_tcsnicmp(szPathPtr, szExpectedString, szSeparator - szPathPtr)) { // Copy the name string for(; szPathPtr < szPathEnd; szPathPtr++) { if(szPathPtr[0] != _T('/') && szPathPtr[0] != _T('#')) szPatchPrefix[nLength++] = (char)szPathPtr[0]; else szPatchPrefix[nLength++] = '\\'; } // Check and create the patch prefix bResult = CheckAndCreatePatchPrefix(haPatch, szPatchPrefix, nLength); } } return bResult; } static bool FindPatchPrefix_SC2_ArchiveName(TMPQArchive * haBase, TMPQArchive * haPatch) { const TCHAR * szPathBegin = FileStream_GetFileName(haBase->pStream); const TCHAR * szSeparator = NULL; const TCHAR * szPathEnd = szPathBegin + _tcslen(szPathBegin); const TCHAR * szPathPtr; int nSlashCount = 0; int nDotCount = 0; // Skip the part where the patch prefix would be too long if((szPathEnd - szPathBegin) > MAX_SC2_PATCH_PREFIX) szPathBegin = szPathEnd - MAX_SC2_PATCH_PREFIX; // Search for the file extension for(szPathPtr = szPathEnd; szPathPtr > szPathBegin; szPathPtr--) { if(szPathPtr[0] == _T('.')) { nDotCount++; break; } } // Search for the possible begin of the prefix name for(/* NOTHING */; szPathPtr > szPathBegin; szPathPtr--) { // Check the slashes, backslashes and hashes if(szPathPtr[0] == _T('\\') || szPathPtr[0] == _T('/') || szPathPtr[0] == _T('#')) { if(nDotCount == 0) return false; szSeparator = szPathPtr; nSlashCount++; } // Check the path parts if(szSeparator != NULL && nSlashCount >= nDotCount) { if(CheckPatchPrefix_SC2_ArchiveName(haPatch, szPathPtr, szSeparator, szPathEnd, _T("Battle.net"), 10)) return true; if(CheckPatchPrefix_SC2_ArchiveName(haPatch, szPathPtr, szSeparator, szPathEnd, _T("Campaigns"), 9)) return true; if(CheckPatchPrefix_SC2_ArchiveName(haPatch, szPathPtr, szSeparator, szPathEnd, _T("Mods"), 4)) return true; } } // Not matched, sorry return false; } // // This method tries to read the patch prefix from a helper file // // Example // ========================================================= // MPQ File Name: MPQ_2013_v4_Base1.SC2Data // Helper File : MPQ_2013_v4_Base1.SC2Data-PATCH // File Contains: PatchPrefix=Mods\Core.SC2Mod\Base.SC2Data // Patch Prefix : Mods\Core.SC2Mod\Base.SC2Data // static bool ExtractPatchPrefixFromFile(const TCHAR * szHelperFile, char * szPatchPrefix, size_t nMaxChars, size_t * PtrLength) { TFileStream * pStream; ULONGLONG FileSize = 0; size_t nLength; char szFileData[MAX_PATH+1]; bool bResult = false; pStream = FileStream_OpenFile(szHelperFile, STREAM_FLAG_READ_ONLY); if(pStream != NULL) { // Retrieve and check the file size FileStream_GetSize(pStream, &FileSize); if(12 <= FileSize && FileSize < MAX_PATH) { // Read the entire file to memory if(FileStream_Read(pStream, NULL, szFileData, (DWORD)FileSize)) { // Terminate the buffer with zero szFileData[(DWORD)FileSize] = 0; // The file data must begin with the "PatchPrefix" variable if(!_strnicmp(szFileData, "PatchPrefix", 11)) { char * szLinePtr = szFileData + 11; char * szLineEnd; // Skip spaces or '=' while(szLinePtr[0] == ' ' || szLinePtr[0] == '=') szLinePtr++; szLineEnd = szLinePtr; // Find the end while(szLineEnd[0] != 0 && szLineEnd[0] != 0x0A && szLineEnd[0] != 0x0D) szLineEnd++; nLength = (size_t)(szLineEnd - szLinePtr); // Copy the variable if(szLineEnd > szLinePtr && nLength <= nMaxChars) { memcpy(szPatchPrefix, szLinePtr, nLength); szPatchPrefix[nLength] = 0; PtrLength[0] = nLength; bResult = true; } } } } // Close the stream FileStream_Close(pStream); } return bResult; } static bool FindPatchPrefix_SC2_HelperFile(TMPQArchive * haBase, TMPQArchive * haPatch) { TCHAR szHelperFile[MAX_PATH+1]; char szPatchPrefix[MAX_SC2_PATCH_PREFIX+0x41]; size_t nLength = 0; bool bResult = false; // Create the name of the patch helper file _tcscpy(szHelperFile, FileStream_GetFileName(haBase->pStream)); if(_tcslen(szHelperFile) + 6 > MAX_PATH) return false; _tcscat(szHelperFile, _T("-PATCH")); // Open the patch helper file and read the line if(ExtractPatchPrefixFromFile(szHelperFile, szPatchPrefix, MAX_SC2_PATCH_PREFIX, &nLength)) bResult = CheckAndCreatePatchPrefix(haPatch, szPatchPrefix, nLength); return bResult; } // // Find match in Starcraft II patch MPQs // Match a LST file in the root directory if the MPQ with any of the file in subdirectories // // The problem: // File in the base MPQ: enGB-md5.lst // File in the patch MPQ: Campaigns\Liberty.SC2Campaign\enGB.SC2Assets\enGB-md5.lst // Campaigns\Liberty.SC2Campaign\enGB.SC2Data\enGB-md5.lst // Campaigns\LibertyStory.SC2Campaign\enGB.SC2Data\enGB-md5.lst // Campaigns\LibertyStory.SC2Campaign\enGB.SC2Data\enGB-md5.lst Mods\Core.SC2Mod\enGB.SC2Assets\enGB-md5.lst // Mods\Core.SC2Mod\enGB.SC2Data\enGB-md5.lst // Mods\Liberty.SC2Mod\enGB.SC2Assets\enGB-md5.lst // Mods\Liberty.SC2Mod\enGB.SC2Data\enGB-md5.lst // Mods\LibertyMulti.SC2Mod\enGB.SC2Data\enGB-md5.lst // // Solution: // We need to match the file by its MD5 // static bool FindPatchPrefix_SC2_MatchFiles(TMPQArchive * haBase, TMPQArchive * haPatch, TFileEntry * pBaseEntry) { TMPQNamePrefix * pPatchPrefix; char * szPatchFileName; char * szPlainName; size_t cchWorkBuffer = 0x400; bool bResult = false; // First-level patches: Find the same file within the patch archive // and verify by MD5-before-patch if(haBase->haPatch == NULL) { TFileEntry * pFileTableEnd = haPatch->pFileTable + haPatch->dwFileTableSize; TFileEntry * pFileEntry; // Allocate working buffer for merging LST file szPatchFileName = STORM_ALLOC(char, cchWorkBuffer); if(szPatchFileName != NULL) { // Parse the entire file table for(pFileEntry = haPatch->pFileTable; pFileEntry < pFileTableEnd; pFileEntry++) { // Look for "patch_metadata" file if(IsPatchMetadataFile(pFileEntry)) { // Construct the name of the MD5 file strcpy(szPatchFileName, pFileEntry->szFileName); szPlainName = (char *)GetPlainFileName(szPatchFileName); strcpy(szPlainName, pBaseEntry->szFileName); // Check for matching MD5 file if(IsMatchingPatchFile(haPatch, szPatchFileName, pBaseEntry->md5)) { bResult = CreatePatchPrefix(haPatch, szPatchFileName, (size_t)(szPlainName - szPatchFileName)); break; } } } // Delete the merge buffer STORM_FREE(szPatchFileName); } } // For second-level patches, just take the patch prefix from the lower level patch else { // There must be at least two patches in the chain assert(haBase->haPatch->pPatchPrefix != NULL); pPatchPrefix = haBase->haPatch->pPatchPrefix; // Copy the patch prefix bResult = CreatePatchPrefix(haPatch, pPatchPrefix->szPatchPrefix, pPatchPrefix->nLength); } return bResult; } // Note: pBaseEntry is the file entry of the base version of "StreamingBuckets.txt" static bool FindPatchPrefix_SC2(TMPQArchive * haBase, TMPQArchive * haPatch, TFileEntry * pBaseEntry) { // Method 1: Try it by the placement of the archive. // Works when someone is opening an archive in the game (sub)directory if(FindPatchPrefix_SC2_ArchiveName(haBase, haPatch)) return true; // Method 2: Try to locate the Name.Ext-PATCH file and read the patch prefix from it if(FindPatchPrefix_SC2_HelperFile(haBase, haPatch)) return true; // Method 3: Try to pair any version of "StreamingBuckets.txt" from the patch MPQ // with the "StreamingBuckets.txt" in the base MPQ. Does not always work if(FindPatchPrefix_SC2_MatchFiles(haBase, haPatch, pBaseEntry)) return true; return false; } // // Patch prefix is the path subdirectory where the patched files are within MPQ. // // Example 1: // Main MPQ: locale-enGB.MPQ // Patch MPQ: wow-update-12694.MPQ // File in main MPQ: DBFilesClient\Achievement.dbc // File in patch MPQ: enGB\DBFilesClient\Achievement.dbc // Path prefix: enGB // // Example 2: // Main MPQ: expansion1.MPQ // Patch MPQ: wow-update-12694.MPQ // File in main MPQ: DBFilesClient\Achievement.dbc // File in patch MPQ: Base\DBFilesClient\Achievement.dbc // Path prefix: Base // // Example 3: // Main MPQ: %GAME%\Battle.net\Battle.net.MPQ // Patch MPQ: s2-update-base-26147.MPQ // File in main MPQ: Battle.net\i18n\deDE\String\CLIENT_ACHIEVEMENTS.xml // File in patch MPQ: Battle.net\Battle.net.MPQ\Battle.net\i18n\deDE\String\CLIENT_ACHIEVEMENTS.xml // Path prefix: Battle.net\Battle.net.MPQ // // Example 4: // Main MPQ: %GAME%\Campaigns\Liberty.SC2Campaign\enGB.SC2Data // *OR* %ANY_DIR%\%ANY_NAME%Campaigns#Liberty.SC2Campaign#enGB.SC2Data // Patch MPQ: s2-update-enGB-23258.MPQ // File in main MPQ: LocalizedData\GameHotkeys.txt // File in patch MPQ: Campaigns\Liberty.SC2Campaign\enGB.SC2Data\LocalizedData\GameHotkeys.txt // Patch Prefix: Campaigns\Liberty.SC2Campaign\enGB.SC2Data // static bool FindPatchPrefix(TMPQArchive * haBase, TMPQArchive * haPatch, const char * szPatchPathPrefix) { TFileEntry * pFileEntry; // If the patch prefix was explicitly entered, we use that one if(szPatchPathPrefix != NULL) return CreatePatchPrefix(haPatch, szPatchPathPrefix, 0); // Patches for World of Warcraft - they mostly do not use prefix. // All patches that use patch prefix have the "base\\(patch_metadata) file present if(GetFileEntryLocale(haPatch, "base\\" PATCH_METADATA_NAME, 0)) return FindPatchPrefix_WoW_13164_13623(haBase, haPatch); // Updates for Starcraft II // Match: LocalizedData\GameHotkeys.txt <==> Campaigns\Liberty.SC2Campaign\enGB.SC2Data\LocalizedData\GameHotkeys.txt // All Starcraft II base archives seem to have the file "StreamingBuckets.txt" present pFileEntry = GetFileEntryLocale(haBase, "StreamingBuckets.txt", 0); if(pFileEntry != NULL) return FindPatchPrefix_SC2(haBase, haPatch, pFileEntry); // Diablo III patch MPQs don't use patch prefix // Hearthstone MPQs don't use patch prefix CreatePatchPrefix(haPatch, NULL, 0); return true; } //----------------------------------------------------------------------------- // Public functions (StormLib internals) bool IsIncrementalPatchFile(const void * pvData, DWORD cbData, LPDWORD pdwPatchedFileSize) { PMPQ_PATCH_HEADER pPatchHeader = (PMPQ_PATCH_HEADER)pvData; BLIZZARD_BSDIFF40_FILE DiffFile; DWORD dwPatchType; if(cbData >= sizeof(MPQ_PATCH_HEADER) + sizeof(BLIZZARD_BSDIFF40_FILE)) { dwPatchType = BSWAP_INT32_UNSIGNED(pPatchHeader->dwPatchType); if(dwPatchType == 0x30445342) { // Give the caller the patch file size if(pdwPatchedFileSize != NULL) { Decompress_RLE((LPBYTE)&DiffFile, sizeof(BLIZZARD_BSDIFF40_FILE), (LPBYTE)(pPatchHeader + 1), sizeof(BLIZZARD_BSDIFF40_FILE)); DiffFile.NewFileSize = BSWAP_INT64_UNSIGNED(DiffFile.NewFileSize); *pdwPatchedFileSize = (DWORD)DiffFile.NewFileSize; return true; } } } return false; } DWORD Patch_InitPatcher(TMPQPatcher * pPatcher, TMPQFile * hf) { DWORD cbMaxFileData = 0; // Overflow check if((cbMaxFileData + (DWORD)sizeof(MPQ_PATCH_HEADER)) < cbMaxFileData) return ERROR_NOT_ENOUGH_MEMORY; if(hf->hfPatch == NULL) return ERROR_INVALID_PARAMETER; // Initialize the entire structure with zeros memset(pPatcher, 0, sizeof(TMPQPatcher)); // Copy the MD5 of the current file memcpy(pPatcher->this_md5, hf->pFileEntry->md5, MD5_DIGEST_SIZE); // Find out the biggest data size needed during the patching process while(hf != NULL) { if(hf->pFileEntry->dwFileSize > cbMaxFileData) cbMaxFileData = hf->pFileEntry->dwFileSize; hf = hf->hfPatch; } // Allocate primary and secondary buffer pPatcher->pbFileData1 = STORM_ALLOC(BYTE, cbMaxFileData); pPatcher->pbFileData2 = STORM_ALLOC(BYTE, cbMaxFileData); if(!pPatcher->pbFileData1 || !pPatcher->pbFileData2) return ERROR_NOT_ENOUGH_MEMORY; pPatcher->cbMaxFileData = cbMaxFileData; return ERROR_SUCCESS; } // // Note: The patch may either be applied to the base file or to the previous version // In Starcraft II, Mods\Core.SC2Mod\Base.SC2Data, file StreamingBuckets.txt: // // Base file MD5: 31376b0344b6df59ad009d4296125539 // // s2-update-base-23258: from 31376b0344b6df59ad009d4296125539 to 941a82683452e54bf024a8d491501824 // s2-update-base-24540: from 31376b0344b6df59ad009d4296125539 to 941a82683452e54bf024a8d491501824 // s2-update-base-26147: from 31376b0344b6df59ad009d4296125539 to d5d5253c762fac6b9761240288a0771a // s2-update-base-28522: from 31376b0344b6df59ad009d4296125539 to 5a76c4b356920aab7afd22e0e1913d7a // s2-update-base-30508: from 31376b0344b6df59ad009d4296125539 to 8cb0d4799893fe801cc78ae4488a3671 // s2-update-base-32283: from 31376b0344b6df59ad009d4296125539 to 8cb0d4799893fe801cc78ae4488a3671 // // We don't keep all intermediate versions in memory, as it would cause massive // memory usage during patching process. A prime example is the file // DBFilesClient\\Item-Sparse.db2 from locale-enGB.MPQ (WoW 16965), which has // 9 patches in a row, each requiring 70 MB memory (35 MB patch data + 35 MB work buffer) // DWORD Patch_Process(TMPQPatcher * pPatcher, TMPQFile * hf) { PMPQ_PATCH_HEADER pFullPatch; MPQ_PATCH_HEADER PatchHeader1; MPQ_PATCH_HEADER PatchHeader2 = {0}; TMPQFile * hfBase = hf; DWORD cbBytesRead = 0; DWORD dwErrCode = ERROR_SUCCESS; // Move to the first patch assert(hfBase->pbFileData == NULL); assert(hfBase->cbFileData == 0); hf = hf->hfPatch; // Read the header of the current patch SFileReadFile((HANDLE)hf, &PatchHeader1, sizeof(MPQ_PATCH_HEADER), &cbBytesRead, NULL); if(cbBytesRead != sizeof(MPQ_PATCH_HEADER)) return ERROR_FILE_CORRUPT; // Perform the patching process while(dwErrCode == ERROR_SUCCESS && hf != NULL) { // Try to read the next patch header. If the md5_before_patch // still matches we go directly to the next one and repeat while(hf->hfPatch != NULL) { // Attempt to read the patch header SFileReadFile((HANDLE)hf->hfPatch, &PatchHeader2, sizeof(MPQ_PATCH_HEADER), &cbBytesRead, NULL); if(cbBytesRead != sizeof(MPQ_PATCH_HEADER)) return ERROR_FILE_CORRUPT; // Compare the md5_before_patch if(memcmp(PatchHeader2.md5_before_patch, pPatcher->this_md5, MD5_DIGEST_SIZE)) break; // Move one patch fuhrter PatchHeader1 = PatchHeader2; hf = hf->hfPatch; } // Allocate memory for the patch data pFullPatch = LoadFullFilePatch(hf, PatchHeader1); if(pFullPatch != NULL) { // Apply the patch dwErrCode = ApplyFilePatch(pPatcher, pFullPatch); STORM_FREE(pFullPatch); } else { dwErrCode = ERROR_FILE_CORRUPT; } // Move to the next patch PatchHeader1 = PatchHeader2; pPatcher->nCounter++; hf = hf->hfPatch; } // Put the result data to the file structure if(dwErrCode == ERROR_SUCCESS) { // Swap the pointer to the file data structure if(pPatcher->nCounter & 0x01) { hfBase->pbFileData = pPatcher->pbFileData2; pPatcher->pbFileData2 = NULL; } else { hfBase->pbFileData = pPatcher->pbFileData1; pPatcher->pbFileData1 = NULL; } // Also supply the data size hfBase->cbFileData = pPatcher->cbFileData; } return ERROR_SUCCESS; } void Patch_Finalize(TMPQPatcher * pPatcher) { if(pPatcher != NULL) { if(pPatcher->pbFileData1 != NULL) STORM_FREE(pPatcher->pbFileData1); if(pPatcher->pbFileData2 != NULL) STORM_FREE(pPatcher->pbFileData2); memset(pPatcher, 0, sizeof(TMPQPatcher)); } } //----------------------------------------------------------------------------- // Public functions bool WINAPI SFileOpenPatchArchive( HANDLE hMpq, const TCHAR * szPatchMpqName, const char * szPatchPathPrefix, DWORD dwFlags) { TMPQArchive * haPatch; TMPQArchive * ha = (TMPQArchive *)hMpq; HANDLE hPatchMpq = NULL; DWORD dwErrCode = ERROR_SUCCESS; // Verify input parameters if(!IsValidMpqHandle(hMpq)) dwErrCode = ERROR_INVALID_HANDLE; if(szPatchMpqName == NULL || *szPatchMpqName == 0) dwErrCode = ERROR_INVALID_PARAMETER; // // We don't allow adding patches to archives that have been open for write // // Error scenario: // // 1) Open archive for writing // 2) Modify or replace a file // 3) Add patch archive to the opened MPQ // 4) Read patched file // 5) Now what? // if(dwErrCode == ERROR_SUCCESS) { if(!(ha->dwFlags & MPQ_FLAG_READ_ONLY)) dwErrCode = ERROR_ACCESS_DENIED; } // Open the archive like it is normal archive if(dwErrCode == ERROR_SUCCESS) { // These flags will be propagated to SFileOpenArchive dwFlags = (dwFlags & MPQ_OPEN_NO_LISTFILE) | MPQ_OPEN_READ_ONLY | MPQ_OPEN_PATCH; // Open the patch as MPQ if(SFileOpenArchive(szPatchMpqName, 0, dwFlags, &hPatchMpq)) { // Cast the archive handle to structure pointer haPatch = (TMPQArchive *)hPatchMpq; // We need to remember the proper patch prefix to match names of patched files if(FindPatchPrefix(ha, (TMPQArchive *)hPatchMpq, szPatchPathPrefix)) { // Now add the patch archive to the list of patches to the original MPQ while(ha != NULL) { if(ha->haPatch == NULL) { haPatch->haBase = ha; ha->haPatch = haPatch; return true; } // Move to the next archive ha = ha->haPatch; } } // Close the archive SFileCloseArchive(hPatchMpq); dwErrCode = ERROR_CANT_FIND_PATCH_PREFIX; } else { dwErrCode = SErrGetLastError(); } } SErrSetLastError(dwErrCode); return false; } bool WINAPI SFileIsPatchedArchive(HANDLE hMpq) { TMPQArchive * ha = (TMPQArchive *)hMpq; // Verify input parameters if(!IsValidMpqHandle(hMpq)) return false; return (ha->haPatch != NULL); }