Files
Viano-Core/dep/StormLib/src/FileStream.cpp
T

1862 lines
63 KiB
C++

/*****************************************************************************/
/* FileStream.cpp Copyright (c) Ladislav Zezula 2010 */
/*---------------------------------------------------------------------------*/
/* File stream support for StormLib */
/* */
/* Windows support: Written by Ladislav Zezula */
/* Mac support: Written by Sam Wilkins */
/* Linux support: Written by Sam Wilkins and Ivan Komissarov */
/* Big-endian: Written & debugged by Sam Wilkins */
/*---------------------------------------------------------------------------*/
/* Date Ver Who Comment */
/* -------- ---- --- ------- */
/* 11.06.10 1.00 Lad Derived from StormPortMac.cpp and StormPortLinux.cpp */
/*****************************************************************************/
#define __STORMLIB_SELF__
#include "StormLib.h"
#include "StormCommon.h"
//-----------------------------------------------------------------------------
// Local defines
#ifndef INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE ((HANDLE)-1)
#endif
#ifdef _MSC_VER
#pragma warning(disable: 4800) // 'BOOL' : forcing value to bool 'true' or 'false' (performance warning)
#endif
//-----------------------------------------------------------------------------
// Local structures
// Structure describing the PART file header
typedef struct _PART_FILE_HEADER
{
DWORD PartialVersion; // Always set to 2
char GameBuildNumber[8]; // Minimum build number of the game that can use this MPQ
DWORD Unknown0C;
DWORD Unknown10;
DWORD Unknown14; // Often contains 0x1C (size of the rest of the header ?)
DWORD Unknown18;
DWORD ZeroValue1C; // Seems to always be zero
DWORD ZeroValue20; // Seems to always be zero
DWORD ZeroValue24; // Seems to always be zero
DWORD FileSizeLo; // Low 32 bits of the file size
DWORD FileSizeHi; // High 32 bits of the file size
DWORD BlockSize; // Size of one file block, in bytes
} PART_FILE_HEADER, *PPART_FILE_HEADER;
// Structure describing the block-to-file map entry
typedef struct _PART_FILE_MAP_ENTRY
{
DWORD Flags; // 3 = the block is present in the file
DWORD BlockOffsLo; // Low 32 bits of the block position in the file
DWORD BlockOffsHi; // High 32 bits of the block position in the file
DWORD Unknown0C;
DWORD Unknown10;
} PART_FILE_MAP_ENTRY, *PPART_FILE_MAP_ENTRY;
struct TPartFileStream : public TFileStream
{
ULONGLONG VirtualSize; // Virtual size of the file
ULONGLONG VirtualPos; // Virtual position in the file
DWORD BlockCount; // Number of file blocks. Used by partial file stream
DWORD BlockSize; // Size of one block. Used by partial file stream
PART_FILE_MAP_ENTRY PartMap[1]; // File map, variable length
};
#define MPQE_CHUNK_SIZE 0x40 // Size of one chunk to be decrypted
struct TEncryptedStream : public TFileStream
{
BYTE Key[MPQE_CHUNK_SIZE]; // File key
};
static bool IsPartHeader(PPART_FILE_HEADER pPartHdr)
{
// Version number must be 2
if(pPartHdr->PartialVersion == 2)
{
// GameBuildNumber must be anm ASCII number
if(isdigit(pPartHdr->GameBuildNumber[0]) && isdigit(pPartHdr->GameBuildNumber[1]) && isdigit(pPartHdr->GameBuildNumber[2]))
{
// Block size must be power of 2
if((pPartHdr->BlockSize & (pPartHdr->BlockSize - 1)) == 0)
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Non-Windows support for LastError
#ifndef PLATFORM_WINDOWS
static int nLastError = ERROR_SUCCESS;
int GetLastError()
{
return nLastError;
}
void SetLastError(int nError)
{
nLastError = nError;
}
#endif
//-----------------------------------------------------------------------------
// Local functions - platform-specific functions
#ifndef PLATFORM_LITTLE_ENDIAN
void ConvertPartHeader(void * partHeader)
{
PPART_FILE_HEADER theHeader = (PPART_FILE_HEADER)partHeader;
theHeader->PartialVersion = SwapUInt32(theHeader->PartialVersion);
theHeader->Unknown0C = SwapUInt32(theHeader->Unknown0C);
theHeader->Unknown10 = SwapUInt32(theHeader->Unknown10);
theHeader->Unknown14 = SwapUInt32(theHeader->Unknown14);
theHeader->Unknown18 = SwapUInt32(theHeader->Unknown18);
theHeader->Unknown1C = SwapUInt32(theHeader->Unknown1C);
theHeader->Unknown20 = SwapUInt32(theHeader->Unknown20);
theHeader->ZeroValue = SwapUInt32(theHeader->ZeroValue);
theHeader->FileSizeLo = SwapUInt32(theHeader->FileSizeLo);
theHeader->FileSizeHi = SwapUInt32(theHeader->FileSizeHi);
theHeader->BlockSize = SwapUInt32(theHeader->BlockSize);
}
#endif
#ifdef PLATFORM_MAC
static void ConvertUTCDateTimeToFileTime(const UTCDateTimePtr inTime, ULONGLONG * pFT)
{
UInt64 intTime = ((UInt64)inTime->highSeconds << 32) + inTime->lowSeconds;
intTime *= 10000000;
intTime += 0x0153b281e0fb4000ull;
*pFT = intTime;
}
static OSErr FSOpenDFCompat(FSRef *ref, char permission, short *refNum)
{
HFSUniStr255 forkName;
OSErr theErr;
Boolean isFolder, wasChanged;
theErr = FSResolveAliasFile(ref, true, &isFolder, &wasChanged);
if (theErr != noErr)
{
return theErr;
}
FSGetDataForkName(&forkName);
#ifdef PLATFORM_64BIT
theErr = FSOpenFork(ref, forkName.length, forkName.unicode, permission, (FSIORefNum *)refNum);
#else
theErr = FSOpenFork(ref, forkName.length, forkName.unicode, permission, refNum);
#endif
return theErr;
}
#endif
#ifdef PLATFORM_LINUX
// time_t is number of seconds since 1.1.1970, UTC.
// 1 second = 10000000 (decimal) in FILETIME
static void ConvertTimeTToFileTime(ULONGLONG * pFileTime, time_t crt_time)
{
// Set the start to 1.1.1970 00:00:00
*pFileTime = 0x019DB1DED53E8000ULL + (10000000 * crt_time);
}
#endif
static HANDLE CreateNewFile(
const TCHAR * szFileName) // Name of the file to open
{
HANDLE hFile = INVALID_HANDLE_VALUE; // Pre-set the file handle to INVALID_HANDLE_VALUE
#ifdef PLATFORM_WINDOWS
{
DWORD dwShareMode = FILE_SHARE_READ;
if(dwGlobalFlags & SFILE_FLAG_ALLOW_WRITE_SHARE)
dwShareMode |= FILE_SHARE_WRITE;
hFile = CreateFile(szFileName,
GENERIC_READ | GENERIC_WRITE,
dwShareMode,
NULL,
CREATE_ALWAYS,
0,
NULL);
}
#endif
#ifdef PLATFORM_MAC
{
FSRef theParentRef;
FSRef theFileRef;
OSErr theErr;
short fileRef;
theErr = FSPathMakeRef((const UInt8 *)szFileName, &theFileRef, NULL);
if (theErr == noErr)
FSDeleteObject(&theFileRef);
// Create the FSRef for the parent directory.
UInt8 folderName[MAX_PATH];
memset(&theFileRef, 0, sizeof(FSRef));
CFStringRef filePathCFString = CFStringCreateWithCString(NULL, szFileName, kCFStringEncodingUTF8);
CFURLRef fileURL = CFURLCreateWithFileSystemPath(NULL, filePathCFString, kCFURLPOSIXPathStyle, false);
CFURLRef folderURL = CFURLCreateCopyDeletingLastPathComponent(NULL, fileURL);
CFURLGetFileSystemRepresentation(folderURL, true, folderName, MAX_PATH);
theErr = FSPathMakeRef(folderName, &theParentRef, NULL);
CFRelease(fileURL);
CFRelease(folderURL);
if (theErr != noErr)
{
nLastError = theErr;
return INVALID_HANDLE_VALUE;
}
// Create the file
UniChar unicodeFileName[256];
fileURL = CFURLCreateWithFileSystemPath(NULL, filePathCFString, kCFURLPOSIXPathStyle, false);
CFStringRef fileNameCFString = CFURLCopyLastPathComponent(fileURL);
CFStringGetCharacters(fileNameCFString, CFRangeMake(0, CFStringGetLength(fileNameCFString)),
unicodeFileName);
theErr = FSCreateFileUnicode(&theParentRef, CFStringGetLength(fileNameCFString), unicodeFileName,
kFSCatInfoNone, NULL, &theFileRef, NULL);
CFRelease(fileNameCFString);
CFRelease(filePathCFString);
CFRelease(fileURL);
if (theErr != noErr)
{
nLastError = theErr;
return INVALID_HANDLE_VALUE;
}
theErr = FSOpenDFCompat(&theFileRef, fsRdWrPerm, &fileRef);
if(theErr != noErr)
{
nLastError = theErr;
return INVALID_HANDLE_VALUE;
}
hFile = (HANDLE)(int)fileRef;
}
#endif
#ifdef PLATFORM_LINUX
{
intptr_t handle;
handle = open(szFileName, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if(handle == -1)
{
nLastError = errno;
return INVALID_HANDLE_VALUE;
}
hFile = (HANDLE)handle;
}
#endif
// Return the file handle
return hFile;
}
static HANDLE OpenExistingFile(
const TCHAR * szFileName, // Name of the file to open
bool bWriteAccess) // false = read-only, true = read/write
{
HANDLE hFile = INVALID_HANDLE_VALUE; // Pre-set the file handle to INVALID_HANDLE_VALUE
#ifdef PLATFORM_WINDOWS
{
DWORD dwShareMode = FILE_SHARE_READ;
if(dwGlobalFlags & SFILE_FLAG_ALLOW_WRITE_SHARE)
dwShareMode |= FILE_SHARE_WRITE;
hFile = CreateFile(szFileName,
bWriteAccess ? (GENERIC_READ | GENERIC_WRITE) : GENERIC_READ,
dwShareMode,
NULL,
OPEN_EXISTING,
0,
NULL);
}
#endif
#ifdef PLATFORM_MAC
{
FSRef theFileRef;
OSErr theErr;
short fileRef;
char permission = bWriteAccess ? fsRdWrPerm : fsRdPerm;
theErr = FSPathMakeRef((const UInt8 *)szFileName, &theFileRef, NULL);
if(theErr != noErr)
{
nLastError = theErr;
return INVALID_HANDLE_VALUE;
}
theErr = FSOpenDFCompat(&theFileRef, permission, &fileRef);
if (theErr != noErr)
{
nLastError = theErr;
return INVALID_HANDLE_VALUE;
}
hFile = (HANDLE)(int)fileRef;
}
#endif
#ifdef PLATFORM_LINUX
{
int oflag = bWriteAccess ? O_RDWR : O_RDONLY;
intptr_t handle;
handle = open(szFileName, oflag | O_LARGEFILE);
if(handle == -1)
{
nLastError = errno;
return INVALID_HANDLE_VALUE;
}
hFile = (HANDLE)handle;
}
#endif
// Return the file handle
return hFile;
}
static void CloseTheFile(HANDLE hFile)
{
#ifdef PLATFORM_WINDOWS
CloseHandle(hFile);
#endif
#ifdef PLATFORM_MAC
FSCloseFork((short)(long)hFile);
#endif
#ifdef PLATFORM_LINUX
close((intptr_t)hFile);
#endif
}
/**
* Renames a file to another name.
* Note that the "szNewFile" file usually exists when this function is called,
* so the function must deal with it properly
*/
static bool RenameFile(const TCHAR * szExistingFile, const TCHAR * szNewFile)
{
#ifdef PLATFORM_WINDOWS
// Delete the original stream file. Don't check the result value,
// because if the file doesn't exist, it would fail
DeleteFile(szNewFile);
// Rename the new file to the old stream's file
return (bool)MoveFile(szExistingFile, szNewFile);
#endif
#ifdef PLATFORM_MAC
OSErr theErr;
FSRef fromFileRef;
FSRef toFileRef;
if (FSPathMakeRef((const UInt8 *)szNewFile, &toFileRef, NULL) == noErr)
FSDeleteObject(&toFileRef);
// Get the path to the old file
theErr = FSPathMakeRef((const UInt8 *)szExistingFile, &fromFileRef, NULL);
if (theErr != noErr)
{
nLastError = theErr;
return false;
}
// Get a CFString for the new file name
CFStringRef newFileNameCFString = CFStringCreateWithCString(NULL, szNewFile, kCFStringEncodingUTF8);
CFURLRef fileURL = CFURLCreateWithFileSystemPath(NULL, newFileNameCFString, kCFURLPOSIXPathStyle, false);
CFRelease(newFileNameCFString);
newFileNameCFString = CFURLCopyLastPathComponent(fileURL);
CFRelease(fileURL);
// Convert CFString to Unicode and rename the file
UniChar unicodeFileName[256];
CFStringGetCharacters(newFileNameCFString, CFRangeMake(0, CFStringGetLength(newFileNameCFString)),
unicodeFileName);
theErr = FSRenameUnicode(&fromFileRef, CFStringGetLength(newFileNameCFString), unicodeFileName,
kTextEncodingUnknown, NULL);
if (theErr != noErr)
{
CFRelease(newFileNameCFString);
nLastError = theErr;
return false;
}
CFRelease(newFileNameCFString);
return true;
#endif
#ifdef PLATFORM_LINUX
// "rename" on Linux also works if the target file exists
if(rename(szExistingFile, szNewFile) == -1)
{
nLastError = errno;
return false;
}
return true;
#endif
}
//-----------------------------------------------------------------------------
// Stream functions - normal file stream
static bool File_GetPos(
TFileStream * pStream, // Pointer to an open stream
ULONGLONG & ByteOffset) // Pointer to file byte offset
{
ByteOffset = pStream->RawFilePos;
return true;
}
static bool File_Read(
TFileStream * pStream, // Pointer to an open stream
ULONGLONG * pByteOffset, // Pointer to file byte offset. If NULL, it reads from the current position
void * pvBuffer, // Pointer to data to be read
DWORD dwBytesToRead) // Number of bytes to read from the file
{
DWORD dwBytesRead = 0; // Must be set by platform-specific code
// If the byte offset is not entered, use the current position
if(pByteOffset == NULL)
pByteOffset = &pStream->RawFilePos;
#ifdef PLATFORM_WINDOWS
{
// If the byte offset is different from the current file position,
// we have to update the file position
if(*pByteOffset != pStream->RawFilePos)
{
LONG ByteOffsetHi = (LONG)(*pByteOffset >> 32);
LONG ByteOffsetLo = (LONG)(*pByteOffset);
SetFilePointer(pStream->hFile, ByteOffsetLo, &ByteOffsetHi, FILE_BEGIN);
pStream->RawFilePos = *pByteOffset;
}
// Read the data
if(dwBytesToRead != 0)
{
if(!ReadFile(pStream->hFile, pvBuffer, dwBytesToRead, &dwBytesRead, NULL))
return false;
}
}
#endif
#ifdef PLATFORM_MAC
{
ByteCount nBytesToRead = (ByteCount)dwBytesToRead;
ByteCount nBytesRead = 0;
OSErr theErr;
// If the byte offset is different from the current file position,
// we have to update the file position
if(*pByteOffset != pStream->RawFilePos)
{
FSSetForkPosition((short)(long)pStream->hFile, fsFromStart, (SInt64)(*pByteOffset));
pStream->RawFilePos = *pByteOffset;
}
// Read the data
if(nBytesToRead != 0)
{
theErr = FSReadFork((short)(long)pStream->hFile, fsAtMark, 0, nBytesToRead, pvBuffer, &nBytesRead);
if (theErr != noErr && theErr != eofErr)
{
nLastError = theErr;
return false;
}
dwBytesRead = (DWORD)nBytesRead;
}
}
#endif
#ifdef PLATFORM_LINUX
{
ssize_t bytes_read;
// If the byte offset is different from the current file position,
// we have to update the file position
if(*pByteOffset != pStream->RawFilePos)
{
lseek64((intptr_t)pStream->hFile, (off64_t)(*pByteOffset), SEEK_SET);
pStream->RawFilePos = *pByteOffset;
}
// Perform the read operation
if(dwBytesToRead != 0)
{
bytes_read = read((intptr_t)pStream->hFile, pvBuffer, (size_t)dwBytesToRead);
if(bytes_read == -1)
{
nLastError = errno;
return false;
}
dwBytesRead = (DWORD)(size_t)bytes_read;
}
}
#endif
// Increment the current file position by number of bytes read
// If the number of bytes read doesn't match to required amount, return false
pStream->RawFilePos = *pByteOffset + dwBytesRead;
if(dwBytesRead != dwBytesToRead)
SetLastError(ERROR_HANDLE_EOF);
return (dwBytesRead == dwBytesToRead);
}
/**
* \a pStream Pointer to an open stream
* \a pByteOffset Pointer to file byte offset. If NULL, writes to current position
* \a pvBuffer Pointer to data to be written
* \a dwBytesToWrite Number of bytes to write to the file
*/
static bool File_Write(TFileStream * pStream, ULONGLONG * pByteOffset, const void * pvBuffer, DWORD dwBytesToWrite)
{
DWORD dwBytesWritten = 0; // Must be set by platform-specific code
// If the byte offset is not entered, use the current position
if(pByteOffset == NULL)
pByteOffset = &pStream->RawFilePos;
#ifdef PLATFORM_WINDOWS
{
// If the byte offset is different from the current file position,
// we have to update the file position
if(*pByteOffset != pStream->RawFilePos)
{
LONG ByteOffsetHi = (LONG)(*pByteOffset >> 32);
LONG ByteOffsetLo = (LONG)(*pByteOffset);
SetFilePointer(pStream->hFile, ByteOffsetLo, &ByteOffsetHi, FILE_BEGIN);
pStream->RawFilePos = *pByteOffset;
}
// Read the data
if(!WriteFile(pStream->hFile, pvBuffer, dwBytesToWrite, &dwBytesWritten, NULL))
return false;
}
#endif
#ifdef PLATFORM_MAC
{
ByteCount nBytesToWrite = (ByteCount)dwBytesToWrite;
ByteCount nBytesWritten = 0;
OSErr theErr;
// If the byte offset is different from the current file position,
// we have to update the file position
if(*pByteOffset != pStream->RawFilePos)
{
FSSetForkPosition((short)(long)pStream->hFile, fsFromStart, (SInt64)(*pByteOffset));
pStream->RawFilePos = *pByteOffset;
}
theErr = FSWriteFork((short)(long)pStream->hFile, fsAtMark, 0, nBytesToWrite, pvBuffer, &nBytesWritten);
if (theErr != noErr)
{
nLastError = theErr;
return false;
}
dwBytesWritten = (DWORD)nBytesWritten;
}
#endif
#ifdef PLATFORM_LINUX
{
ssize_t bytes_written;
// If the byte offset is different from the current file position,
// we have to update the file position
if(*pByteOffset != pStream->RawFilePos)
{
lseek64((intptr_t)pStream->hFile, (off64_t)(*pByteOffset), SEEK_SET);
pStream->RawFilePos = *pByteOffset;
}
// Perform the read operation
bytes_written = write((intptr_t)pStream->hFile, pvBuffer, (size_t)dwBytesToWrite);
if(bytes_written == -1)
{
nLastError = errno;
return false;
}
dwBytesWritten = (DWORD)(size_t)bytes_written;
}
#endif
// Increment the current file position by number of bytes read
pStream->RawFilePos = *pByteOffset + dwBytesWritten;
if(dwBytesWritten != dwBytesToWrite)
SetLastError(ERROR_DISK_FULL);
return (dwBytesWritten == dwBytesToWrite);
}
static bool File_GetSize(
TFileStream * pStream, // Pointer to an open stream
ULONGLONG & FileSize) // Pointer where to store file size
{
#ifdef PLATFORM_WINDOWS
DWORD FileSizeHi = 0;
DWORD FileSizeLo;
FileSizeLo = GetFileSize(pStream->hFile, &FileSizeHi);
if(FileSizeLo == INVALID_FILE_SIZE && GetLastError() != ERROR_SUCCESS)
return false;
FileSize = MAKE_OFFSET64(FileSizeHi, FileSizeLo);
return true;
#endif
#ifdef PLATFORM_MAC
SInt64 fileLength = 0;
OSErr theErr;
theErr = FSGetForkSize((short)(long)pStream->hFile, &fileLength);
if(theErr != noErr)
{
nLastError = theErr;
return false;
}
FileSize = (ULONGLONG)fileLength;
return true;
#endif
#ifdef PLATFORM_LINUX
struct stat64 fileinfo;
if(fstat64((intptr_t)pStream->hFile, &fileinfo) == -1)
{
nLastError = errno;
return false;
}
FileSize = (ULONGLONG)fileinfo.st_size;
return true;
#endif
}
/**
* \a pStream Pointer to an open stream
* \a NewFileSize New size of the file
*/
static bool File_SetSize(TFileStream * pStream, ULONGLONG NewFileSize)
{
#ifdef PLATFORM_WINDOWS
{
LONG FileSizeHi = (LONG)(NewFileSize >> 32);
LONG FileSizeLo = (LONG)(NewFileSize);
DWORD dwNewPos;
bool bResult;
// Set the position at the new file size
dwNewPos = SetFilePointer(pStream->hFile, FileSizeLo, &FileSizeHi, FILE_BEGIN);
if(dwNewPos == INVALID_SET_FILE_POINTER && GetLastError() != ERROR_SUCCESS)
return false;
// Set the current file pointer as the end of the file
bResult = (bool)SetEndOfFile(pStream->hFile);
// Restore the file position
FileSizeHi = (LONG)(pStream->RawFilePos >> 32);
FileSizeLo = (LONG)(pStream->RawFilePos);
SetFilePointer(pStream->hFile, FileSizeLo, &FileSizeHi, FILE_BEGIN);
return bResult;
}
#endif
#ifdef PLATFORM_MAC
{
OSErr theErr;
theErr = FSSetForkSize((short)(long)pStream->hFile, fsFromStart, (SInt64)NewFileSize);
if(theErr != noErr)
{
nLastError = theErr;
return false;
}
return true;
}
#endif
#ifdef PLATFORM_LINUX
{
if(ftruncate((intptr_t)pStream->hFile, (off_t)NewFileSize) == -1)
{
nLastError = errno;
return false;
}
return true;
}
#endif
}
//-----------------------------------------------------------------------------
// Stream functions - partial normal file stream
/**
* \a pStream Pointer to an open stream
* \a ByteOffset File byte offset
*/
static bool PartFile_GetPos(TPartFileStream * pStream, ULONGLONG & ByteOffset)
{
ByteOffset = pStream->VirtualPos;
return true;
}
/**
* \a pStream Pointer to an open stream
* \a pByteOffset Pointer to file byte offset. If NULL, reads from the current position
* \a pvBuffer Pointer to data to be read
* \a dwBytesToRead Number of bytes to read from the file
*/
static bool PartFile_Read(TPartFileStream * pStream, ULONGLONG * pByteOffset, void * pvBuffer, DWORD dwBytesToRead)
{
ULONGLONG RawByteOffset;
LPBYTE pbBuffer = (LPBYTE)pvBuffer;
DWORD dwBytesRemaining = dwBytesToRead;
DWORD dwPartOffset;
DWORD dwPartIndex;
DWORD dwBytesRead = 0;
DWORD dwBlockSize = pStream->BlockSize;
bool bResult = false;
int nFailReason = ERROR_HANDLE_EOF; // Why it failed if not enough bytes was read
// If the byte offset is not entered, use the current position
if(pByteOffset == NULL)
pByteOffset = &pStream->VirtualPos;
// Check if the file position is not at or beyond end of the file
if(*pByteOffset >= pStream->VirtualSize)
{
SetLastError(ERROR_HANDLE_EOF);
return false;
}
// Get the part index where the read offset is
// Note that the part index should now be within the range,
// as read requests beyond-EOF are handled by the previous test
dwPartIndex = (DWORD)(*pByteOffset / pStream->BlockSize);
assert(dwPartIndex < pStream->BlockCount);
// If the number of bytes remaining goes past
// the end of the file, cut them
if((*pByteOffset + dwBytesRemaining) > pStream->VirtualSize)
dwBytesRemaining = (DWORD)(pStream->VirtualSize - *pByteOffset);
// Calculate the offset in the current part
dwPartOffset = (DWORD)(*pByteOffset) & (pStream->BlockSize - 1);
// Read all data, one part at a time
while(dwBytesRemaining != 0)
{
PPART_FILE_MAP_ENTRY PartMap = pStream->PartMap + dwPartIndex;
DWORD dwBytesInPart;
// If the part is not present in the file, we fail the read
if((PartMap->Flags & 3) == 0)
{
nFailReason = ERROR_CAN_NOT_COMPLETE;
bResult = false;
break;
}
// If we are in the last part, we have to cut the number of bytes in the last part
if(dwPartIndex == pStream->BlockCount - 1)
dwBlockSize = (DWORD)pStream->VirtualSize & (pStream->BlockSize - 1);
// Get the number of bytes reamining in the current part
dwBytesInPart = dwBlockSize - dwPartOffset;
// Compute the raw file offset of the file part
RawByteOffset = MAKE_OFFSET64(PartMap->BlockOffsHi, PartMap->BlockOffsLo);
if(RawByteOffset == 0)
{
nFailReason = ERROR_CAN_NOT_COMPLETE;
bResult = false;
break;
}
// If the number of bytes in part is too big, cut it
if(dwBytesInPart > dwBytesRemaining)
dwBytesInPart = dwBytesRemaining;
// Append the offset within the part
RawByteOffset += dwPartOffset;
if(!File_Read(pStream, &RawByteOffset, pbBuffer, dwBytesInPart))
{
nFailReason = ERROR_CAN_NOT_COMPLETE;
bResult = false;
break;
}
// Increment the file position
dwBytesRemaining -= dwBytesInPart;
dwBytesRead += dwBytesInPart;
pbBuffer += dwBytesInPart;
// Move to the next file part
dwPartOffset = 0;
dwPartIndex++;
}
// Move the file position by the number of bytes read
pStream->VirtualPos = *pByteOffset + dwBytesRead;
if(dwBytesRead != dwBytesToRead)
SetLastError(nFailReason);
return (dwBytesRead == dwBytesToRead);
}
static bool PartFile_Write(
TPartFileStream * pStream, // Pointer to an open stream
ULONGLONG * pByteOffset, // Pointer to file byte offset. If NULL, it reads from the current position
const void * pvBuffer, // Pointer to data to be read
DWORD dwBytesToRead) // Number of bytes to read from the file
{
// Keep compiler happy
dwBytesToRead = dwBytesToRead;
pByteOffset = pByteOffset;
pvBuffer = pvBuffer;
pStream = pStream;
// Not allowed
return false;
}
static bool PartFile_GetSize(
TPartFileStream * pStream, // Pointer to an open stream
ULONGLONG & FileSize) // Pointer where to store file size
{
FileSize = pStream->VirtualSize;
return true;
}
static bool PartFile_SetSize(
TPartFileStream * pStream, // Pointer to an open stream
ULONGLONG NewSize) // new size of the file
{
// Keep compiler happy
pStream = pStream;
NewSize = NewSize;
// Not allowed
return false;
}
/*
* Stream functions - encrypted stream
*
* Note: In original Starcraft II Installer.exe: Suffix derived from battle.net auth. code
* Address of decryption routine: 0053A3D0 http://us.battle.net/static/mediakey/sc2-authenticationcode-enUS.txt
* Pointer to decryptor object: ECX Numbers mean offset of 4-char group of auth code
* Pointer to key: ECX+0x5C -0C- -1C--08- -18--04- -14--00- -10-
*/
static const char * MpqeKey_Starcraft2_Install_enUS = "expand 32-byte kTFD80000ETR5VM5G0000K859RE5N0000WT6F3DH500005LXG";
static const char * MpqeKey_Starcraft2_Install_enGB = "expand 32-byte kANGY000029ZH6NA20000HRGF8UDG0000NY82G8MN00006A3D";
static const char * MpqeKey_Starcraft2_Install_deDE = "expand 32-byte kSSXH00004XFXK4KX00008EKJD3CA0000Y64ZY45M0000YD9V";
static const char * MpqeKey_Starcraft2_Install_esES = "expand 32-byte kQU4Y0000XKTQ94PF0000N4R4UAXE0000AZ248WLK0000249P";
static const char * MpqeKey_Starcraft2_Install_frFR = "expand 32-byte kFWPQ00006EAJ8HJE0000PFER9K9300008MA2ZG7J0000UA76";
static const char * MpqeKey_Starcraft2_Install_itIT = "expand 32-byte kXV7E00008BL2TVAP0000GVMWUNNN0000SVBWNE7C00003G2B";
static const char * MpqeKey_Starcraft2_Install_plPL = "expand 32-byte k83U6000048L6LULJ00004MQDB8ME0000UP6K2NSF0000YHA3";
static const char * MpqeKey_Starcraft2_Install_ruRU = "expand 32-byte k9SH70000YEGT4BAT0000QDK978W60000V9NLVHB30000D68V";
static const char * MpqKeyArray[] =
{
MpqeKey_Starcraft2_Install_enUS,
MpqeKey_Starcraft2_Install_enGB,
MpqeKey_Starcraft2_Install_deDE,
MpqeKey_Starcraft2_Install_esES,
MpqeKey_Starcraft2_Install_frFR,
MpqeKey_Starcraft2_Install_itIT,
MpqeKey_Starcraft2_Install_plPL,
MpqeKey_Starcraft2_Install_ruRU,
NULL
};
static DWORD Rol32(DWORD dwValue, DWORD dwRolCount)
{
DWORD dwShiftRight = 32 - dwRolCount;
return (dwValue << dwRolCount) | (dwValue >> dwShiftRight);
}
static void DecryptFileChunk(
DWORD * MpqData,
LPBYTE pbKey,
ULONGLONG ByteOffset,
DWORD dwLength)
{
ULONGLONG ChunkOffset;
DWORD KeyShuffled[0x10];
DWORD KeyMirror[0x10];
DWORD RoundCount = 0x14;
// Prepare the key
ChunkOffset = ByteOffset / MPQE_CHUNK_SIZE;
memcpy(KeyMirror, pbKey, MPQE_CHUNK_SIZE);
BSWAP_ARRAY32_UNSIGNED(KeyMirror, MPQE_CHUNK_SIZE);
KeyMirror[0x05] = (DWORD)(ChunkOffset >> 32);
KeyMirror[0x08] = (DWORD)(ChunkOffset);
while(dwLength >= MPQE_CHUNK_SIZE)
{
// Shuffle the key - part 1
KeyShuffled[0x0E] = KeyMirror[0x00];
KeyShuffled[0x0C] = KeyMirror[0x01];
KeyShuffled[0x05] = KeyMirror[0x02];
KeyShuffled[0x0F] = KeyMirror[0x03];
KeyShuffled[0x0A] = KeyMirror[0x04];
KeyShuffled[0x07] = KeyMirror[0x05];
KeyShuffled[0x0B] = KeyMirror[0x06];
KeyShuffled[0x09] = KeyMirror[0x07];
KeyShuffled[0x03] = KeyMirror[0x08];
KeyShuffled[0x06] = KeyMirror[0x09];
KeyShuffled[0x08] = KeyMirror[0x0A];
KeyShuffled[0x0D] = KeyMirror[0x0B];
KeyShuffled[0x02] = KeyMirror[0x0C];
KeyShuffled[0x04] = KeyMirror[0x0D];
KeyShuffled[0x01] = KeyMirror[0x0E];
KeyShuffled[0x00] = KeyMirror[0x0F];
// Shuffle the key - part 2
for(DWORD i = 0; i < RoundCount; i += 2)
{
KeyShuffled[0x0A] = KeyShuffled[0x0A] ^ Rol32((KeyShuffled[0x0E] + KeyShuffled[0x02]), 0x07);
KeyShuffled[0x03] = KeyShuffled[0x03] ^ Rol32((KeyShuffled[0x0A] + KeyShuffled[0x0E]), 0x09);
KeyShuffled[0x02] = KeyShuffled[0x02] ^ Rol32((KeyShuffled[0x03] + KeyShuffled[0x0A]), 0x0D);
KeyShuffled[0x0E] = KeyShuffled[0x0E] ^ Rol32((KeyShuffled[0x02] + KeyShuffled[0x03]), 0x12);
KeyShuffled[0x07] = KeyShuffled[0x07] ^ Rol32((KeyShuffled[0x0C] + KeyShuffled[0x04]), 0x07);
KeyShuffled[0x06] = KeyShuffled[0x06] ^ Rol32((KeyShuffled[0x07] + KeyShuffled[0x0C]), 0x09);
KeyShuffled[0x04] = KeyShuffled[0x04] ^ Rol32((KeyShuffled[0x06] + KeyShuffled[0x07]), 0x0D);
KeyShuffled[0x0C] = KeyShuffled[0x0C] ^ Rol32((KeyShuffled[0x04] + KeyShuffled[0x06]), 0x12);
KeyShuffled[0x0B] = KeyShuffled[0x0B] ^ Rol32((KeyShuffled[0x05] + KeyShuffled[0x01]), 0x07);
KeyShuffled[0x08] = KeyShuffled[0x08] ^ Rol32((KeyShuffled[0x0B] + KeyShuffled[0x05]), 0x09);
KeyShuffled[0x01] = KeyShuffled[0x01] ^ Rol32((KeyShuffled[0x08] + KeyShuffled[0x0B]), 0x0D);
KeyShuffled[0x05] = KeyShuffled[0x05] ^ Rol32((KeyShuffled[0x01] + KeyShuffled[0x08]), 0x12);
KeyShuffled[0x09] = KeyShuffled[0x09] ^ Rol32((KeyShuffled[0x0F] + KeyShuffled[0x00]), 0x07);
KeyShuffled[0x0D] = KeyShuffled[0x0D] ^ Rol32((KeyShuffled[0x09] + KeyShuffled[0x0F]), 0x09);
KeyShuffled[0x00] = KeyShuffled[0x00] ^ Rol32((KeyShuffled[0x0D] + KeyShuffled[0x09]), 0x0D);
KeyShuffled[0x0F] = KeyShuffled[0x0F] ^ Rol32((KeyShuffled[0x00] + KeyShuffled[0x0D]), 0x12);
KeyShuffled[0x04] = KeyShuffled[0x04] ^ Rol32((KeyShuffled[0x0E] + KeyShuffled[0x09]), 0x07);
KeyShuffled[0x08] = KeyShuffled[0x08] ^ Rol32((KeyShuffled[0x04] + KeyShuffled[0x0E]), 0x09);
KeyShuffled[0x09] = KeyShuffled[0x09] ^ Rol32((KeyShuffled[0x08] + KeyShuffled[0x04]), 0x0D);
KeyShuffled[0x0E] = KeyShuffled[0x0E] ^ Rol32((KeyShuffled[0x09] + KeyShuffled[0x08]), 0x12);
KeyShuffled[0x01] = KeyShuffled[0x01] ^ Rol32((KeyShuffled[0x0C] + KeyShuffled[0x0A]), 0x07);
KeyShuffled[0x0D] = KeyShuffled[0x0D] ^ Rol32((KeyShuffled[0x01] + KeyShuffled[0x0C]), 0x09);
KeyShuffled[0x0A] = KeyShuffled[0x0A] ^ Rol32((KeyShuffled[0x0D] + KeyShuffled[0x01]), 0x0D);
KeyShuffled[0x0C] = KeyShuffled[0x0C] ^ Rol32((KeyShuffled[0x0A] + KeyShuffled[0x0D]), 0x12);
KeyShuffled[0x00] = KeyShuffled[0x00] ^ Rol32((KeyShuffled[0x05] + KeyShuffled[0x07]), 0x07);
KeyShuffled[0x03] = KeyShuffled[0x03] ^ Rol32((KeyShuffled[0x00] + KeyShuffled[0x05]), 0x09);
KeyShuffled[0x07] = KeyShuffled[0x07] ^ Rol32((KeyShuffled[0x03] + KeyShuffled[0x00]), 0x0D);
KeyShuffled[0x05] = KeyShuffled[0x05] ^ Rol32((KeyShuffled[0x07] + KeyShuffled[0x03]), 0x12);
KeyShuffled[0x02] = KeyShuffled[0x02] ^ Rol32((KeyShuffled[0x0F] + KeyShuffled[0x0B]), 0x07);
KeyShuffled[0x06] = KeyShuffled[0x06] ^ Rol32((KeyShuffled[0x02] + KeyShuffled[0x0F]), 0x09);
KeyShuffled[0x0B] = KeyShuffled[0x0B] ^ Rol32((KeyShuffled[0x06] + KeyShuffled[0x02]), 0x0D);
KeyShuffled[0x0F] = KeyShuffled[0x0F] ^ Rol32((KeyShuffled[0x0B] + KeyShuffled[0x06]), 0x12);
}
// Decrypt one data chunk
BSWAP_ARRAY32_UNSIGNED(MpqData, MPQE_CHUNK_SIZE);
MpqData[0x00] = MpqData[0x00] ^ (KeyShuffled[0x0E] + KeyMirror[0x00]);
MpqData[0x01] = MpqData[0x01] ^ (KeyShuffled[0x04] + KeyMirror[0x0D]);
MpqData[0x02] = MpqData[0x02] ^ (KeyShuffled[0x08] + KeyMirror[0x0A]);
MpqData[0x03] = MpqData[0x03] ^ (KeyShuffled[0x09] + KeyMirror[0x07]);
MpqData[0x04] = MpqData[0x04] ^ (KeyShuffled[0x0A] + KeyMirror[0x04]);
MpqData[0x05] = MpqData[0x05] ^ (KeyShuffled[0x0C] + KeyMirror[0x01]);
MpqData[0x06] = MpqData[0x06] ^ (KeyShuffled[0x01] + KeyMirror[0x0E]);
MpqData[0x07] = MpqData[0x07] ^ (KeyShuffled[0x0D] + KeyMirror[0x0B]);
MpqData[0x08] = MpqData[0x08] ^ (KeyShuffled[0x03] + KeyMirror[0x08]);
MpqData[0x09] = MpqData[0x09] ^ (KeyShuffled[0x07] + KeyMirror[0x05]);
MpqData[0x0A] = MpqData[0x0A] ^ (KeyShuffled[0x05] + KeyMirror[0x02]);
MpqData[0x0B] = MpqData[0x0B] ^ (KeyShuffled[0x00] + KeyMirror[0x0F]);
MpqData[0x0C] = MpqData[0x0C] ^ (KeyShuffled[0x02] + KeyMirror[0x0C]);
MpqData[0x0D] = MpqData[0x0D] ^ (KeyShuffled[0x06] + KeyMirror[0x09]);
MpqData[0x0E] = MpqData[0x0E] ^ (KeyShuffled[0x0B] + KeyMirror[0x06]);
MpqData[0x0F] = MpqData[0x0F] ^ (KeyShuffled[0x0F] + KeyMirror[0x03]);
BSWAP_ARRAY32_UNSIGNED(MpqData, MPQE_CHUNK_SIZE);
// Update byte offset in the key
KeyMirror[0x08]++;
if(KeyMirror[0x08] == 0)
KeyMirror[0x05]++;
// Move pointers and decrease number of bytes to decrypt
MpqData += (MPQE_CHUNK_SIZE / sizeof(DWORD));
dwLength -= MPQE_CHUNK_SIZE;
}
}
static bool DetectFileKey(TEncryptedStream * pStream)
{
ULONGLONG ByteOffset = 0;
BYTE EncryptedHeader[MPQE_CHUNK_SIZE];
BYTE FileHeader[MPQE_CHUNK_SIZE];
// Load the chunk from the file
if(!FileStream_Read(pStream, &ByteOffset, EncryptedHeader, sizeof(EncryptedHeader)))
return false;
// We just try all known keys one by one
for(int i = 0; MpqKeyArray[i] != NULL; i++)
{
// Copy the key there
memcpy(pStream->Key, MpqKeyArray[i], MPQE_CHUNK_SIZE);
BSWAP_ARRAY32_UNSIGNED(pStream->Key, MPQE_CHUNK_SIZE);
// Try to decrypt with the given key
memcpy(FileHeader, EncryptedHeader, MPQE_CHUNK_SIZE);
DecryptFileChunk((LPDWORD)FileHeader, pStream->Key, ByteOffset, MPQE_CHUNK_SIZE);
// We check the decrypoted data
// All known encrypted MPQs have header at the begin of the file,
// so we check for MPQ signature there.
if(FileHeader[0] == 'M' && FileHeader[1] == 'P' && FileHeader[2] == 'Q')
return true;
}
// Key not found, sorry
return false;
}
static bool EncryptedFile_Read(
TEncryptedStream * pStream, // Pointer to an open stream
ULONGLONG * pByteOffset, // Pointer to file byte offset. If NULL, it reads from the current position
void * pvBuffer, // Pointer to data to be read
DWORD dwBytesToRead) // Number of bytes to read from the file
{
ULONGLONG StartOffset; // Offset of the first byte to be read from the file
ULONGLONG ByteOffset; // Offset that the caller wants
ULONGLONG EndOffset; // End offset that is to be read from the file
DWORD dwBytesToAllocate;
DWORD dwBytesToDecrypt;
DWORD dwOffsetInCache;
LPBYTE pbMpqData = NULL;
bool bResult = false;
// Get the byte offset
if(pByteOffset != NULL)
ByteOffset = *pByteOffset;
else
ByteOffset = pStream->RawFilePos;
// Cut it down to MPQE chunk size
StartOffset = ByteOffset;
StartOffset = StartOffset & ~(MPQE_CHUNK_SIZE - 1);
EndOffset = ByteOffset + dwBytesToRead;
// Calculate number of bytes to decrypt
dwBytesToDecrypt = (DWORD)(EndOffset - StartOffset);
dwBytesToAllocate = (dwBytesToDecrypt + (MPQE_CHUNK_SIZE - 1)) & ~(MPQE_CHUNK_SIZE - 1);
// Allocate buffers for encrypted and decrypted data
pbMpqData = STORM_ALLOC(BYTE, dwBytesToAllocate);
if(pbMpqData)
{
// Get the offset of the desired data in the cache
dwOffsetInCache = (DWORD)(ByteOffset - StartOffset);
// Read the file from the stream as-is
if(File_Read(pStream, &StartOffset, pbMpqData, dwBytesToDecrypt))
{
// Decrypt the data
DecryptFileChunk((LPDWORD)pbMpqData, pStream->Key, StartOffset, dwBytesToAllocate);
// Copy the decrypted data
memcpy(pvBuffer, pbMpqData + dwOffsetInCache, dwBytesToRead);
bResult = true;
}
else
{
assert(false);
}
// Free decryption buffer
STORM_FREE(pbMpqData);
}
// Free buffers and exit
return bResult;
}
static bool EncryptedFile_Write(
TEncryptedStream * pStream, // Pointer to an open stream
ULONGLONG * pByteOffset, // Pointer to file byte offset. If NULL, it reads from the current position
const void * pvBuffer, // Pointer to data to be read
DWORD dwBytesToRead) // Number of bytes to read from the file
{
// Keep compiler happy
dwBytesToRead = dwBytesToRead;
pByteOffset = pByteOffset;
pvBuffer = pvBuffer;
pStream = pStream;
// Not allowed
return false;
}
static bool EncryptedFile_SetSize(
TEncryptedStream * pStream, // Pointer to an open stream
ULONGLONG NewSize) // new size of the file
{
// Keep compiler happy
pStream = pStream;
NewSize = NewSize;
// Not allowed
return false;
}
//-----------------------------------------------------------------------------
// Public functions
/**
* This function creates a new file for read or read-write access
*
* - If the current platform supports file sharing,
* the file must be created for read sharing (i.e. another application
* can open the file for read, but not for write)
* - If the file does not exist, the function must create new one
* - If the file exists, the function must rewrite it and set to zero size
* - The parameters of the function must be validate by the caller
* - The function must initialize all stream function pointers in TFileStream
* - If the function fails from any reason, it must close all handles
* and free all memory that has been allocated in the process of stream creation,
* including the TFileStream structure itself
*
* \a szFileName Name of the file to create
*/
TFileStream * FileStream_CreateFile(
const TCHAR * szFileName) // Name of the file to create
{
TFileStream * pStream = NULL;
HANDLE hFile;
// Create the file
hFile = CreateNewFile(szFileName);
if(hFile != INVALID_HANDLE_VALUE)
{
// Allocate the FileStream structure and fill it
pStream = STORM_ALLOC(TFileStream, 1);
if(pStream != NULL)
{
// Reset entire structure to zero
memset(pStream, 0, sizeof(TFileStream));
// Save file name and set function pointers
_tcscpy(pStream->szFileName, szFileName);
pStream->StreamGetPos = File_GetPos;
pStream->StreamRead = File_Read;
pStream->StreamWrite = File_Write;
pStream->StreamGetSize = File_GetSize;
pStream->StreamSetSize = File_SetSize;
pStream->hFile = hFile;
}
else
{
CloseTheFile(hFile);
}
}
// Return the stream
return pStream;
}
/**
* This function opens an existing file for read or read-write access
* - If the current platform supports file sharing,
* the file must be open for read sharing (i.e. another application
* can open the file for read, but not for write)
* - If the file does not exist, the function must return NULL
* - If the file exists but cannot be open, then function must return NULL
* - The parameters of the function must be validate by the caller
* - The function must check if the file is a PART file,
* and create TPartFileStream object if so.
* - The function must initialize all stream function pointers in TFileStream
* - If the function fails from any reason, it must close all handles
* and free all memory that has been allocated in the process of stream creation,
* including the TFileStream structure itself
*
* \a szFileName Name of the file to open
* \a bWriteAccess false for read only, true for read+write
*/
TFileStream * FileStream_OpenRawFile(
const TCHAR * szFileName, // Name of the file to create
bool bWriteAccess) // false = read-only, true = read+write
{
TFileStream * pStream;
HANDLE hFile;
// Create the file
hFile = OpenExistingFile(szFileName, bWriteAccess);
if(hFile == INVALID_HANDLE_VALUE)
return NULL;
// Initialize the file as normal file stream
pStream = STORM_ALLOC(TFileStream, 1);
if(pStream != NULL)
{
// Reset entire structure to zero
memset(pStream, 0, sizeof(TFileStream));
// Save file name and set function pointers
_tcscpy(pStream->szFileName, szFileName);
pStream->StreamGetPos = File_GetPos;
pStream->StreamRead = File_Read;
pStream->StreamWrite = File_Write;
pStream->StreamGetSize = File_GetSize;
pStream->StreamSetSize = File_SetSize;
if(bWriteAccess == false)
pStream->StreamFlags |= STREAM_FLAG_READ_ONLY;
pStream->hFile = hFile;
return pStream;
}
CloseTheFile(hFile);
return NULL;
}
/**
* Opens a file
*
* \a szFileName Name of the file to open
* \a bWriteAccess false for read only, true for read+write
*/
TFileStream * FileStream_OpenFile(const TCHAR * szFileName, bool bWriteAccess)
{
PART_FILE_HEADER PartHdr;
ULONGLONG VirtualSize; // Size of the file stored in part file
ULONGLONG ByteOffset = {0};
TFileStream * pStream;
size_t nStructLength;
DWORD BlockCount;
// Open the file as normal stream
pStream = FileStream_OpenRawFile(szFileName, bWriteAccess);
if(pStream == NULL)
return NULL;
// Attempt to read PART file header
if(FileStream_Read(pStream, &ByteOffset, &PartHdr, sizeof(PART_FILE_HEADER)))
{
// We need to swap PART file header on big-endian platforms
BSWAP_PART_HEADER(&PartHdr);
// Verify the PART file header
if(IsPartHeader(&PartHdr))
{
TPartFileStream * pPartStream;
// Calculate the number of parts in the file
VirtualSize = MAKE_OFFSET64(PartHdr.FileSizeHi, PartHdr.FileSizeLo);
BlockCount = (DWORD)((VirtualSize + PartHdr.BlockSize - 1) / PartHdr.BlockSize);
// Calculate the size of the entire structure
// Note that we decrement number of parts by one,
// because there already is one entry in the TPartFileStream structure
nStructLength = sizeof(TPartFileStream) + (BlockCount - 1) * sizeof(PART_FILE_MAP_ENTRY);
pPartStream = (TPartFileStream *)STORM_ALLOC(char, nStructLength);
if(pPartStream != NULL)
{
// Initialize the part file stream
memset(pPartStream, 0, nStructLength);
memcpy(pPartStream, pStream, sizeof(TFileStream));
// Load the block map
if(!FileStream_Read(pPartStream, NULL, pPartStream->PartMap, BlockCount * sizeof(PART_FILE_MAP_ENTRY)))
{
FileStream_Close(pStream);
STORM_FREE(pPartStream);
return NULL;
}
// Swap the array of file map entries
BSWAP_ARRAY32_UNSIGNED(pPartStream->PartMap, BlockCount * sizeof(PART_FILE_MAP_ENTRY));
// Set new function pointers
pPartStream->StreamGetPos = (STREAM_GETPOS)PartFile_GetPos;
pPartStream->StreamRead = (STREAM_READ)PartFile_Read;
pPartStream->StreamWrite = (STREAM_WRITE)PartFile_Write;
pPartStream->StreamGetSize = (STREAM_GETSIZE)PartFile_GetSize;
pPartStream->StreamSetSize = (STREAM_SETSIZE)PartFile_SetSize;
pPartStream->StreamFlags |= (STREAM_FLAG_READ_ONLY | STREAM_FLAG_PART_FILE);
// Fill the members of PART file stream
pPartStream->VirtualSize = ((ULONGLONG)PartHdr.FileSizeHi) + PartHdr.FileSizeLo;
pPartStream->VirtualPos = 0;
pPartStream->BlockCount = BlockCount;
pPartStream->BlockSize = PartHdr.BlockSize;
STORM_FREE(pStream);
}
return pPartStream;
}
}
// If the file doesn't contain PART file header,
// reset the file position to begin of the file
FileStream_Read(pStream, &ByteOffset, NULL, 0);
return pStream;
}
TFileStream * FileStream_OpenEncrypted(const TCHAR * szFileName)
{
TEncryptedStream * pEncryptedStream;
TFileStream * pStream;
// Open the file as raw stream
pStream = FileStream_OpenRawFile(szFileName, false);
if(pStream)
{
// Allocate new stream for handling encryption
pEncryptedStream = STORM_ALLOC(TEncryptedStream, 1);
if(pEncryptedStream != NULL)
{
// Copy the file stream to the encrypted stream
memset(pEncryptedStream, 0, sizeof(TEncryptedStream));
memcpy(pEncryptedStream, pStream, sizeof(TFileStream));
// Assign functions
pEncryptedStream->StreamRead = (STREAM_READ)EncryptedFile_Read;
pEncryptedStream->StreamWrite = (STREAM_WRITE)EncryptedFile_Write;
pEncryptedStream->StreamSetSize = (STREAM_SETSIZE)EncryptedFile_SetSize;
pEncryptedStream->StreamFlags |= (STREAM_FLAG_READ_ONLY | STREAM_FLAG_ENCRYPTED_FILE);
// Get the file key
if(DetectFileKey(pEncryptedStream))
return pEncryptedStream;
// Close the encrypted stream
STORM_FREE(pEncryptedStream);
pEncryptedStream = NULL;
}
FileStream_Close(pStream);
pStream = NULL;
}
SetLastError(ERROR_UNKNOWN_FILE_KEY);
return NULL;
}
/**
* This function returns the current file position
* \a pStream
* \a ByteOffset
*/
bool FileStream_GetPos(TFileStream * pStream, ULONGLONG & ByteOffset)
{
assert(pStream->StreamGetPos != NULL);
return pStream->StreamGetPos(pStream, ByteOffset);
}
/**
* Reads data from the stream
*
* - Returns true if the read operation succeeded and all bytes have been read
* - Returns false if either read failed or not all bytes have been read
* - If the pByteOffset is NULL, the function must read the data from the current file position
* - The function can be called with dwBytesToRead = 0. In that case, pvBuffer is ignored
* and the function just adjusts file pointer.
*
* \a pStream Pointer to an open stream
* \a pByteOffset Pointer to file byte offset. If NULL, it reads from the current position
* \a pvBuffer Pointer to data to be read
* \a dwBytesToRead Number of bytes to read from the file
*
* \returns
* - If the function reads the required amount of bytes, it returns true.
* - If the function reads less than required bytes, it returns false and GetLastError() returns ERROR_HANDLE_EOF
* - If the function fails, it reads false and GetLastError() returns an error code different from ERROR_HANDLE_EOF
*/
bool FileStream_Read(TFileStream * pStream, ULONGLONG * pByteOffset, void * pvBuffer, DWORD dwBytesToRead)
{
assert(pStream->StreamRead != NULL);
return pStream->StreamRead(pStream, pByteOffset, pvBuffer, dwBytesToRead);
}
/**
* This function writes data to the stream
*
* - Returns true if the write operation succeeded and all bytes have been written
* - Returns false if either write failed or not all bytes have been written
* - If the pByteOffset is NULL, the function must write the data to the current file position
*
* \a pStream Pointer to an open stream
* \a pByteOffset Pointer to file byte offset. If NULL, it reads from the current position
* \a pvBuffer Pointer to data to be written
* \a dwBytesToWrite Number of bytes to write to the file
*/
bool FileStream_Write(TFileStream * pStream, ULONGLONG * pByteOffset, const void * pvBuffer, DWORD dwBytesToWrite)
{
if(pStream->StreamFlags & STREAM_FLAG_READ_ONLY)
return false;
assert(pStream->StreamWrite != NULL);
return pStream->StreamWrite(pStream, pByteOffset, pvBuffer, dwBytesToWrite);
}
/**
* Returns the last write time of a file
*
* \a pStream Pointer to an open stream
* \a pFileType Pointer where to store the file last write time
*/
bool FileStream_GetLastWriteTime(TFileStream * pStream, ULONGLONG * pFileTime)
{
#ifdef PLATFORM_WINDOWS
FILETIME ft;
if(!GetFileTime(pStream->hFile, NULL, NULL, &ft))
return false;
*pFileTime = MAKE_OFFSET64(ft.dwHighDateTime, ft.dwLowDateTime);
return true;
#endif
#ifdef PLATFORM_MAC
OSErr theErr;
FSRef theFileRef;
FSCatalogInfo theCatInfo;
theErr = FSGetForkCBInfo((short)(long)pStream->hFile, 0, NULL, NULL, NULL, &theFileRef, NULL);
if(theErr != noErr)
{
nLastError = theErr;
return false;
}
theErr = FSGetCatalogInfo(&theFileRef, kFSCatInfoContentMod, &theCatInfo, NULL, NULL, NULL);
if(theErr != noErr)
{
nLastError = theErr;
return false;
}
ConvertUTCDateTimeToFileTime(&theCatInfo.contentModDate, pFileTime);
return true;
#endif
#ifdef PLATFORM_LINUX
struct stat file_stats;
if(fstat((int)(size_t)pStream->hFile, &file_stats) == -1)
{
nLastError = errno;
return false;
}
ConvertTimeTToFileTime(pFileTime, file_stats.st_mtime);
return true;
#endif
}
/**
* Returns the size of a file
*
* \a pStream Pointer to an open stream
* \a FileSize Pointer where to store the file size
*/
bool FileStream_GetSize(TFileStream * pStream, ULONGLONG & FileSize)
{
assert(pStream->StreamGetSize != NULL);
return pStream->StreamGetSize(pStream, FileSize);
}
/**
* Sets the size of a file
*
* \a pStream Pointer to an open stream
* \a NewFileSize File size to set
*/
bool FileStream_SetSize(TFileStream * pStream, ULONGLONG NewFileSize)
{
if(pStream->StreamFlags & STREAM_FLAG_READ_ONLY)
return false;
assert(pStream->StreamSetSize != NULL);
return pStream->StreamSetSize(pStream, NewFileSize);
}
/**
* Switches a stream with another. Used for final phase of archive compacting.
* Performs these steps:
*
* 1) Closes the handle to the existing MPQ
* 2) Renames the temporary MPQ to the original MPQ, overwrites existing one
* 3) Opens the MPQ stores the handle and stream position to the new stream structure
*
* \a pStream Pointer to an open stream
* \a pTempStream Temporary ("working") stream (created during archive compacting)
*/
bool FileStream_MoveFile(TFileStream * pStream, TFileStream * pTempStream)
{
bool bWriteAccess;
// Close the handle to the temporary file
CloseTheFile(pTempStream->hFile);
pTempStream->hFile = INVALID_HANDLE_VALUE;
// Close the handle to the source file
CloseTheFile(pStream->hFile);
pStream->hFile = INVALID_HANDLE_VALUE;
// Rename the temp file to the final file
if(!RenameFile(pTempStream->szFileName, pStream->szFileName))
return false;
// Now open the renamed file again, and store its handle to the old stream
bWriteAccess = (pStream->StreamFlags & STREAM_FLAG_READ_ONLY) ? false : true;
pStream->hFile = OpenExistingFile(pStream->szFileName, bWriteAccess);
if(pStream->hFile == INVALID_HANDLE_VALUE)
return false;
// Delete the temporary file stream
FileStream_Close(pTempStream);
// The file position has been reset to zero by reopening the file
pStream->RawFilePos = 0;
return true;
}
/**
* This function closes an archive file and frees any data buffers
* that have been allocated for stream management. The function must also
* support partially allocated structure, i.e. one or more buffers
* can be NULL, if there was an allocation failure during the process
*
* \a pStream Pointer to an open stream
*/
void FileStream_Close(TFileStream * pStream)
{
// Check if the stream structure is allocated at all
if(pStream != NULL)
{
// Close the file handle
if(pStream->hFile != INVALID_HANDLE_VALUE)
CloseTheFile(pStream->hFile);
// Free the stream itself
STORM_FREE(pStream);
}
}
//-----------------------------------------------------------------------------
// main - for testing purposes
/*
int main(void)
{
ULONGLONG FilePos;
ULONGLONG FileSize;
TMPQFileTime * pFT;
TFileStream * pTempStream;
TFileStream * pStream;
TMPQBlock * pBlock;
TMPQHash * pHash;
TMPQHeader2 MpqHeader;
char szString1[100] = "This is a single line\n\r";
char szString2[100];
char Buffer[0x80];
DWORD dwLength = strlen(szString1);
//
// Test 1: Write to a stream
//
pStream = FileStream_CreateFile("E:\\Stream.bin");
if(pStream == NULL)
{
printf("Failed to create new file\n");
return -1;
}
for(int i = 0; i < 10; i++)
{
if(!FileStream_Write(pStream, NULL, szString1, dwLength))
{
printf("Failed to write to the stream\n");
return -1;
}
}
FileStream_Close(pStream);
//
// Test2: Read from the stream
//
pStream = FileStream_OpenFile("E:\\Stream.bin", false);
if(pStream == NULL)
{
printf("Failed to open existing file\n");
return -1;
}
// This call must end with an error
if(FileStream_Write(pStream, NULL, "aaa", 3))
{
printf("Write succeeded while it should fail\n");
return -1;
}
for(int i = 0; i < 10; i++)
{
if(!FileStream_Read(pStream, NULL, szString2, dwLength))
{
printf("Failed to read from the stream\n");
return -1;
}
szString2[dwLength] = 0;
if(strcmp(szString1, szString2))
{
printf("Data read from file are different from data written\n");
return -1;
}
}
FileStream_Close(pStream);
//
// Test3: Open the temp stream, write some data and switch it to the original stream
//
pStream = FileStream_OpenFile("E:\\Stream.bin", false);
if(pStream == NULL)
{
printf("Failed to open existing file\n");
return -1;
}
pTempStream = FileStream_CreateFile("E:\\TempStream.bin");
if(pTempStream == NULL)
{
printf("Failed to create temp stream\n");
return -1;
}
// Copy the original stream to the temp
if(!FileStream_GetSize(pStream, &FileSize))
{
printf("Failed to get the file size\n");
return -1;
}
while(FileSize.QuadPart != 0)
{
DWORD dwBytesToRead = FileSize.LowPart;
if(dwBytesToRead > sizeof(Buffer))
dwBytesToRead = sizeof(Buffer);
if(!FileStream_Read(pStream, NULL, Buffer, dwBytesToRead))
{
printf("CopyStream: Read source file failed\n");
return -1;
}
if(!FileStream_Write(pTempStream, NULL, Buffer, dwBytesToRead))
{
printf("CopyStream: Write target file failed\n");
return -1;
}
FileSize.QuadPart -= dwBytesToRead;
}
// Switch the streams
// Note that the pTempStream is closed by the operation
FileStream_MoveFile(pStream, pTempStream);
FileStream_Close(pStream);
//
// Test4: Read from the stream again
//
pStream = FileStream_OpenFile("E:\\Stream.bin", false);
if(pStream == NULL)
{
printf("Failed to open existing file\n");
return -1;
}
for(int i = 0; i < 10; i++)
{
if(!FileStream_Read(pStream, NULL, szString2, dwLength))
{
printf("Failed to read from the stream\n");
return -1;
}
szString2[dwLength] = 0;
if(strcmp(szString1, szString2))
{
printf("Data read from file are different from data written\n");
return -1;
}
}
FileStream_Close(pStream);
//
// Test5: Open partial MPQ stream
//
// InitializeMpqCryptography();
pStream = FileStream_OpenFile("e:\\Multimedia\\MPQs\\PartialMPQs\\patch.MPQ.part", false);
if(pStream != NULL)
{
// Read the MPQ header
FileStream_Read(pStream, NULL, &MpqHeader, MPQ_HEADER_SIZE_V2);
// Read the hash table
pHash = STORM_ALLOC(TMPQHash, MpqHeader.dwHashTableSize);
FilePos.HighPart = 0;
FilePos.LowPart = MpqHeader.dwHashTablePos;
FileStream_Read(pStream, &FilePos, pHash, MpqHeader.dwHashTableSize * sizeof(TMPQHash));
//
// At this point, the encrypted hash table should be like this:
//
// 416c7175 5ddfb61b 84bb75c8 c0399515
// a9793eca 9ec773d7 ed8a54d6 74fb2adf
// 6acd4ae5 b13816b5 ffad2341 2f2b2a54
// 614339c7 5fd0adf0 62434e91 d62439e3
// 8f317aa5 f12706d6 bd83d2ca 97d7f108
// 7586d373 51d85b05 8540beca f37ef3d7
// d931d4d6 d592aadf 9044e960 c4592e92
// 47dc03f7 0982dea4 afb31943 7c3c7cec
// 0c28fd0d bcbfb7df 4d13b6e4 b5b0ef31
// e1a33b70 ec30e4b9 7aaa5e7a fb6d46ec
// 61732791 55fe757e 8ba18b5d d5f93246
// 6d275f38 a89b5781 c34189a9 654c6472
// 07e1d4e1 814bc8ee c72d2730 815afd43
// 40bd2a92 640a9391 d868f813 0f61b73d
// 6d202746 2c5124ca 65db3ad0 5b1c3e39
// b731013c 73776405 eac0c746 6e50c938
// a4a7fd00 56db3805 6d6dbab7 44fed28a
// 2383394b bf617bdd a3edfaa2 e7d3aaaf
//
// Decrypt the hash table
// DecryptMpqBlock(pHash, MpqHeader.dwHashTableSize * sizeof(TMPQHash), MPQ_KEY_HASH_TABLE);
//
// At this point, the hash table should be like this:
//
// c750beb9 72c2538a 00000000 00000466
// ffffffff ffffffff ffffffff ffffffff
// 898fdc7a 18963b5d 00000000 000005e1
// ffffffff ffffffff ffffffff ffffffff
// e3c6fc32 d8afff2b 00000000 000001ea
// ffffffff ffffffff ffffffff ffffffff
// ffffffff ffffffff ffffffff ffffffff
// ffffffff ffffffff ffffffff ffffffff
// ffffffff ffffffff ffffffff ffffffff
// ffffffff ffffffff ffffffff ffffffff
// ffffffff ffffffff ffffffff ffffffff
// 0fa4fd60 3fbe8626 00000000 0000076f
// 9ee5bccf 031b277b 00000000 0000095c
// f4e154c5 0aadd1c1 00000000 00000876
// 9e1ce9e7 e12d575d 00000000 0000071d
//
// Read the block table
pBlock = STORM_ALLOC(TMPQBlock, MpqHeader.dwBlockTableSize);
FilePos.HighPart = 0;
FilePos.LowPart = MpqHeader.dwBlockTablePos;
FileStream_Read(pStream, &FilePos, pBlock, MpqHeader.dwBlockTableSize * sizeof(TMPQBlock));
//
// At this point, the encrypted block table should be like this:
//
// 3d4867a7 ca0f533e f82c54d6 ed3c9dec
// d8d607dc d9ad13ab f4588b46 8d058704
// e8084fc8 63bc8064 b058c777 3683e9e3
// 6c0da998 7703be0d 91ce3607 c14e29b9
// 481b5c0d 42d902d2 8302acb7 e8f3e715
// c9cdfc91 7cc38c15 ea3dfd22 ad20c856
// b6450c7f 08522866 4cedb064 e03e3a86
// 4509c7cc ddffbfc3 82fc8c66 e82a4424
// afc4a982 23169037 5af6a3e2 34e1d24e
// 362c9e34 846cfc3d 4c611fcd d645fe8f
// f4061640 6d08d196 f330a975 66e30993
// fd96a033 2b16def6 62ff30af 3e190b0b
// 664a5b91 b8558235 fd631825 a7807be7
// ec906b9b 76d8b32e 36f3ea0b 1b0f5391
//
// Decrypt the block table
// DecryptMpqBlock(pBlock, MpqHeader.dwBlockTableSize * sizeof(TMPQBlock), MPQ_KEY_BLOCK_TABLE);
//
// At this point, the block table should be like this:
//
// 0000002c 00078093 00116824 84000200
// 000780bf 000002d5 00008044 84000200
// 00078394 00001516 0000874c 84000200
// 000798aa 00003797 0000af4e 84000200
// 0007d041 000001db 00008044 84000200
// 0007d21c 0000005e 0000005e 84000200
// 0007d27a 000022fb 00009674 84000200
// 0007f575 00002389 00009c64 84000200
// 000818fe 000023cb 00009d58 84000200
// 00083cc9 000024d9 0000a0d8 84000200
// 000861a2 00002356 00009c70 84000200
// 000884f8 000023d3 00009da4 84000200
// 0008a8cb 000022d6 00009cd4 84000200
// 0008cba1 00002339 00009714 84000200
// 0008eeda 000023dc 00009b24 84000200
// 000912b6 00002481 00009eac 84000200
// 00093737 00002444 0000a028 84000200
// 00095b7b 00002440 00009fc4 84000200
//
FileStream_Close(pStream);
}
return 0;
}
*/