bool WINAPI SFileSetHashTableSize(HANDLE hMpq, DWORD dwNewTableSize)
{
SFILE_FIND_DATA sf;
TMPQArchive * ha = (TMPQArchive *)hMpq;
TFileNode ** pListFileToFree = NULL;
TFileNode ** pNewListFile = NULL;
TMPQHash * pOldHashTable = NULL;
TMPQHash * pNewHashTable = NULL;
TMPQHash * pTableToFree = NULL;
TMPQHash * pNewHash = NULL;
HANDLE hFind;
DWORD dwOldTableSize = ha->pHeader->dwHashTableSize;
DWORD dwIndex;
bool bFoundSomething = true;
int nError = ERROR_SUCCESS;
// Test the valid parameters
if(!IsValidMpqHandle(ha))
nError = ERROR_INVALID_HANDLE;
if(ha->dwFlags & MPQ_FLAG_READ_ONLY)
nError = ERROR_ACCESS_DENIED;
// New hash table size must be a power of two
if(dwNewTableSize & (dwNewTableSize - 1))
nError = ERROR_INVALID_PARAMETER;
// Allocate buffers for copy of the old hash table and new hash table
if(nError == ERROR_SUCCESS)
{
pOldHashTable = ALLOCMEM(TMPQHash, dwOldTableSize);
pNewHashTable = ALLOCMEM(TMPQHash, dwNewTableSize);
pNewListFile = ALLOCMEM(TFileNode *, dwNewTableSize);
if(pOldHashTable == NULL || pNewHashTable == NULL)
nError = ERROR_NOT_ENOUGH_MEMORY;
}
// When this function is called, it is already ensured that the parameters are valid
// (e.g. the "dwToRead + dwFilePos" is not greater than the file size)
// TODO: Test for archives > 4GB
static DWORD WINAPI ReadMPQFileSingleUnit(TMPQFile * hf, DWORD dwFilePos, BYTE * pbBuffer, DWORD dwToRead)
{
TMPQArchive * ha = hf->ha;
DWORD dwBytesRead = 0;
if(ha->FilePointer.QuadPart != hf->MpqFilePos.QuadPart)
{
SetFilePointer(ha->hFile, hf->MpqFilePos.LowPart, &hf->MpqFilePos.HighPart, FILE_BEGIN);
ha->FilePointer = hf->MpqFilePos;
}
// If the file is really compressed, decompress it.
// Otherwise, read the data as-is to the caller.
if(hf->pBlock->dwCSize < hf->pBlock->dwFSize)
{
if(hf->pbFileBuffer == NULL)
{
BYTE * inputBuffer = NULL;
int outputBufferSize = (int)hf->pBlock->dwFSize;
int inputBufferSize = (int)hf->pBlock->dwCSize;
hf->pbFileBuffer = ALLOCMEM(BYTE, outputBufferSize);
inputBuffer = ALLOCMEM(BYTE, inputBufferSize);
if(inputBuffer != NULL && hf->pbFileBuffer != NULL)
{
// Read the compressed file data
ReadFile(ha->hFile, inputBuffer, inputBufferSize, &dwBytesRead, NULL);
// Is the file compressed with PKWARE Data Compression Library ?
if(hf->pBlock->dwFlags & MPQ_FILE_COMPRESS_PKWARE)
Decompress_pklib((char *)hf->pbFileBuffer, &outputBufferSize, (char *)inputBuffer, (int)inputBufferSize);
// Is it a file compressed by Blizzard's multiple compression ?
// Note that Storm.dll v 1.0.9 distributed with Warcraft III
// passes the full path name of the opened archive as the new last parameter
if(hf->pBlock->dwFlags & MPQ_FILE_COMPRESS_MULTI)
SCompDecompress((char *)hf->pbFileBuffer, &outputBufferSize, (char *)inputBuffer, (int)inputBufferSize);
}
// Free the temporary buffer
if(inputBuffer != NULL)
FREEMEM(inputBuffer);
}
// Copy the file data, if any there
if(hf->pbFileBuffer != NULL)
{
memcpy(pbBuffer, hf->pbFileBuffer + dwFilePos, dwToRead);
dwBytesRead += dwToRead;
}
}
else
{
// Read the uncompressed file data
ReadFile(ha->hFile, pbBuffer, dwToRead, &dwBytesRead, NULL);
dwBytesRead = (int)dwBytesRead;
}
return (DWORD)dwBytesRead;
}
static int LoadMpqPatch_BSD0(TMPQFile * hf, TPatchHeader * pPatchHeader)
{
LPBYTE pbDecompressed = NULL;
LPBYTE pbCompressed = NULL;
DWORD cbDecompressed = 0;
DWORD cbCompressed = 0;
DWORD dwBytesRead = 0;
int nError = ERROR_SUCCESS;
// Allocate space for compressed data
cbCompressed = pPatchHeader->dwXfrmBlockSize - SIZE_OF_XFRM_HEADER;
pbCompressed = ALLOCMEM(BYTE, cbCompressed);
if(pbCompressed == NULL)
nError = ERROR_SUCCESS;
// Read the compressed patch data
if(nError == ERROR_SUCCESS)
{
// Load the rest of the header
SFileReadFile((HANDLE)hf, pbCompressed, cbCompressed, &dwBytesRead);
if(dwBytesRead != cbCompressed)
nError = ERROR_FILE_CORRUPT;
}
// Get the uncompressed size of the patch
if(nError == ERROR_SUCCESS)
{
cbDecompressed = pPatchHeader->dwSizeOfPatchData - sizeof(TPatchHeader);
hf->pPatchHeader = (TPatchHeader *)ALLOCMEM(BYTE, pPatchHeader->dwSizeOfPatchData);
if(hf->pPatchHeader == NULL)
nError = ERROR_NOT_ENOUGH_MEMORY;
}
// Now decompress the patch data
if(nError == ERROR_SUCCESS)
{
// Copy the patch header
memcpy(hf->pPatchHeader, pPatchHeader, sizeof(TPatchHeader));
pbDecompressed = (LPBYTE)hf->pPatchHeader + sizeof(TPatchHeader);
// Uncompress or copy the patch data
if(cbCompressed < cbDecompressed)
{
Decompress_RLE(pbDecompressed, cbDecompressed, pbCompressed, cbCompressed);
}
else
{
assert(cbCompressed == cbDecompressed);
memcpy(pbDecompressed, pbCompressed, cbCompressed);
}
}
// Free buffers and exit
if(pbCompressed != NULL)
FREEMEM(pbCompressed);
return nError;
}
int SAttrFileCreate(TMPQArchive * ha)
{
TMPQAttr * pNewAttr;
int nError = ERROR_SUCCESS;
// There should NOW be any attributes
assert(ha->pAttributes == NULL);
pNewAttr = ALLOCMEM(TMPQAttr, 1);
if(pNewAttr != NULL)
{
// Pre-set the structure
pNewAttr->dwVersion = MPQ_ATTRIBUTES_V1;
pNewAttr->dwFlags = 0;
// Allocate array for CRC32
pNewAttr->pCrc32 = ALLOCMEM(TMPQCRC32, ha->pHeader->dwHashTableSize);
if(pNewAttr->pCrc32 != NULL)
{
pNewAttr->dwFlags |= MPQ_ATTRIBUTE_CRC32;
memset(pNewAttr->pCrc32, 0, sizeof(TMPQCRC32) * ha->pHeader->dwHashTableSize);
}
else
nError = ERROR_NOT_ENOUGH_MEMORY;
// Allocate array for FILETIME
pNewAttr->pFileTime = ALLOCMEM(TMPQFileTime, ha->pHeader->dwHashTableSize);
if(pNewAttr->pFileTime != NULL)
{
pNewAttr->dwFlags |= MPQ_ATTRIBUTE_FILETIME;
memset(pNewAttr->pFileTime, 0, sizeof(TMPQFileTime) * ha->pHeader->dwHashTableSize);
}
else
nError = ERROR_NOT_ENOUGH_MEMORY;
// Allocate array for MD5
pNewAttr->pMd5 = ALLOCMEM(TMPQMD5, ha->pHeader->dwHashTableSize);
if(pNewAttr->pMd5 != NULL)
{
pNewAttr->dwFlags |= MPQ_ATTRIBUTE_MD5;
memset(pNewAttr->pMd5, 0, sizeof(TMPQMD5) * ha->pHeader->dwHashTableSize);
}
else
nError = ERROR_NOT_ENOUGH_MEMORY;
}
// If something failed, then free the attributes structure
if(nError != ERROR_SUCCESS)
{
FreeMPQAttributes(pNewAttr);
pNewAttr = NULL;
}
ha->pAttributes = pNewAttr;
return nError;
}
// show (make active) a texfont message ---------------------------------------
//
void ShowTexfontMessage( texfontmsg_s *msg )
{
ASSERT( msg != NULL );
//NOTE:
// messages of the same type will replace each other,
// whereas messages of different types will coexist.
// search for msg to replace (according to type)
int msgid = 0;
for ( msgid = 0; msgid < num_texfont_msgs; msgid++ ) {
if ( TexfontMsgs[ msgid ].msgtype == msg->msgtype ) {
FreeTexfontMessage( msgid );
msgid = num_texfont_msgs;
break;
}
}
// guard against table size overflow
if ( msgid >= MAX_TEXFONT_MESSAGES ) {
return;
}
// copy basic info
memcpy( &TexfontMsgs[ msgid ], msg, sizeof( texfontmsg_s ) );
// refalpha may be set explicitly to allow for oversaturated alpha starts
if ( msg->itexfont->Vtxs[ 0 ].A == 0 ) {
TexfontMsgs[ msgid ].curalpha = TexfontMsgs[ msgid ].refalpha;
} else {
TexfontMsgs[ msgid ].refalpha = msg->itexfont->Vtxs[ 0 ].A;
TexfontMsgs[ msgid ].curalpha = msg->itexfont->Vtxs[ 0 ].A;
}
// must make a copy of message string
TexfontMsgs[ msgid ].message = (char *) ALLOCMEM( strlen( msg->message ) + 1 );
if ( TexfontMsgs[ msgid ].message == NULL )
OUTOFMEM( 0 );
strcpy( TexfontMsgs[ msgid ].message, msg->message );
// must make a copy of itertexfont structure
TexfontMsgs[ msgid ].itexfont = (IterTexfont *) ALLOCMEM( sizeof( IterTexfont ) );
if ( TexfontMsgs[ msgid ].itexfont == NULL )
OUTOFMEM( 0 );
memcpy( TexfontMsgs[ msgid ].itexfont, msg->itexfont, sizeof( IterTexfont ) );
// one more active message
num_texfont_msgs++;
}
// create data package --------------------------------------------------------
//
PRIVATE
int CreatePackage( const char* packname, const char *listname )
{
ASSERT( packname != NULL );
ASSERT( listname != NULL );
#define MAX_DATA_FILES 4096
list_item_s *listitems = (list_item_s *) ALLOCMEM( MAX_DATA_FILES * sizeof( list_item_s ) );
if ( listitems == NULL ) {
return FALSE;
}
int numitems = ReadFileList( listname, listitems, MAX_DATA_FILES );
if ( numitems == -1 ) {
FREEMEM( listitems );
MakepackError();
}
if ( !WritePackageFile( packname, listitems, numitems ) ) {
FREEMEM( listitems );
MakepackError();
}
FREEMEM( listitems );
return TRUE;
}
// init keyboard code (alloc mem, setup tables, install handlers) -------------
//
void INPs_KeybInitHandler()
{
// enable unicode character handling for keypress events
#if !SDL_VERSION_ATLEAST(2,0,0)
SDL_EnableUNICODE(SDL_ENABLE);
#endif
// XXX: Not sure if this is needed either....
// prevent multiple inits
if ( sdl_keyb_init_done ) {
return;
}
// alloc key tables
KeyAdditional = (keyaddctrl_s *) ALLOCMEM( sizeof( keyaddctrl_s ) );
// init all structs
memset( DepressedKeys, 0, sizeof( keyfunc_s ) );
memset( KeyAdditional, 0, sizeof( keyaddctrl_s ) );
memset( KeybFlags, 0, sizeof( keybflags_s ) );
KeybFlags->ConTogReleased = (byte)-1;
/*
// grab input
*/
sdl_keyb_init_done = TRUE;
}
static int LoadMpqPatch_COPY(TMPQFile * hf, TPatchHeader * pPatchHeader)
{
int nError = ERROR_SUCCESS;
// Allocate space for patch header and compressed data
hf->pPatchHeader = (TPatchHeader *)ALLOCMEM(BYTE, pPatchHeader->dwSizeOfPatchData);
if(hf->pPatchHeader == NULL)
nError = ERROR_NOT_ENOUGH_MEMORY;
// Load the patch data and decide if they are compressed or not
if(nError == ERROR_SUCCESS)
{
LPBYTE pbPatchFile = (LPBYTE)hf->pPatchHeader;
// Copy the patch header itself
memcpy(pbPatchFile, pPatchHeader, sizeof(TPatchHeader));
pbPatchFile += sizeof(TPatchHeader);
// Load the rest of the patch
if(!SFileReadFile((HANDLE)hf, pbPatchFile, pPatchHeader->dwSizeOfPatchData - sizeof(TPatchHeader)))
nError = GetLastError();
}
return nError;
}
// register object type for vapor trail ---------------------------------------
//
PRIVATE
void VaporTrailRegisterCustomType()
{
custom_type_info_s info;
memset( &info, 0, sizeof( info ) );
// always try to allocate template
vapor_type_template = (VaporTrail *) ALLOCMEM( sizeof( VaporTrail ) );
if ( vapor_type_template != NULL ) {
memset( vapor_type_template, 0, sizeof( VaporTrail ) );
VaporTrailInitDefaults( vapor_type_template );
}
info.type_name = "vaportrail";
info.type_id = 0x00000000;
info.type_size = sizeof( VaporTrail );
info.type_template = vapor_type_template;
info.type_flags = CUSTOM_TYPE_DEFAULT;
info.callback_init = VaporTrailInitType;
info.callback_instant = VaporTrailInstantiate;
info.callback_destroy = VaporTrailDestroy;
info.callback_animate = VaporTrailAnimate;
info.callback_collide = NULL;
info.callback_notify = VaporTrailNotify;
info.callback_persist = NULL;
vapor_type_id = OBJ_RegisterCustomType( &info );
CON_RegisterCustomType( info.type_id, VaporTrail_PropList );
}
static int ReadMpqFilePatchFile(TMPQFile * hf, void * pvBuffer, DWORD dwToRead, LPDWORD pdwBytesRead)
{
DWORD dwBytesToRead = dwToRead;
DWORD dwBytesRead = 0;
int nError = ERROR_SUCCESS;
// Make sure that the patch file is loaded completely
if(hf->pbFileData == NULL)
{
// Load the original file and store its content to "pbOldData"
hf->pbFileData = ALLOCMEM(BYTE, hf->pFileEntry->dwFileSize);
hf->cbFileData = hf->pFileEntry->dwFileSize;
if(hf->pbFileData == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
// Read the file data
if(hf->pFileEntry->dwFlags & MPQ_FILE_SINGLE_UNIT)
nError = ReadMpqFileSingleUnit(hf, hf->pbFileData, hf->cbFileData, &dwBytesRead);
else
nError = ReadMpqFile(hf, hf->pbFileData, hf->cbFileData, &dwBytesRead);
// Fix error code
if(nError == ERROR_SUCCESS && dwBytesRead != hf->cbFileData)
nError = ERROR_FILE_CORRUPT;
// Patch the file data
if(nError == ERROR_SUCCESS)
nError = PatchFileData(hf);
// Reset position to zero
hf->dwFilePos = 0;
dwBytesRead = 0;
}
// If there is something to read, do it
if(nError == ERROR_SUCCESS)
{
if(hf->dwFilePos < hf->cbFileData)
{
// Make sure we don't copy more than file size
if((hf->dwFilePos + dwToRead) > hf->cbFileData)
dwToRead = hf->cbFileData - hf->dwFilePos;
// Copy the appropriate amount of the file data to the caller's buffer
memcpy(pvBuffer, hf->pbFileData + hf->dwFilePos, dwToRead);
hf->dwFilePos += dwToRead;
dwBytesRead = dwToRead;
}
// Set the proper error code
nError = (dwBytesRead == dwBytesToRead) ? ERROR_SUCCESS : ERROR_HANDLE_EOF;
}
// Give the result to the caller
if(pdwBytesRead != NULL)
*pdwBytesRead = dwBytesRead;
return nError;
}
static bool CalculateMpqHashSha1(TMPQArchive * ha, PMPQ_SIGNATURE_INFO pSI, unsigned char * sha1_tail0, unsigned char * sha1_tail1, unsigned char * sha1_tail2) {
ULONGLONG BeginBuffer;
hash_state sha1_state_temp;
hash_state sha1_state;
LPBYTE pbDigestBuffer = NULL;
// Allocate buffer for creating the MPQ digest.
pbDigestBuffer = ALLOCMEM(BYTE, MPQ_DIGEST_UNIT_SIZE);
if (pbDigestBuffer == NULL)
return false;
// Initialize SHA1 state structure
sha1_init(&sha1_state);
// Calculate begin of data to be hashed
BeginBuffer = pSI->BeginMpqData;
// Create the digest
for (;;) {
ULONGLONG BytesRemaining;
DWORD dwToRead = MPQ_DIGEST_UNIT_SIZE;
// Check the number of bytes remaining
BytesRemaining = pSI->EndMpqData - BeginBuffer;
if (BytesRemaining < MPQ_DIGEST_UNIT_SIZE)
dwToRead = (DWORD)BytesRemaining;
if (dwToRead == 0)
break;
// Read the next chunk
if (!FileStream_Read(ha->pStream, &BeginBuffer, pbDigestBuffer, dwToRead)) {
FREEMEM(pbDigestBuffer);
return false;
}
// Pass the buffer to the hashing function
sha1_process(&sha1_state, pbDigestBuffer, dwToRead);
// Move pointers
BeginBuffer += dwToRead;
}
// Add all three known tails and generate three hashes
memcpy(&sha1_state_temp, &sha1_state, sizeof(hash_state));
sha1_done(&sha1_state_temp, sha1_tail0);
memcpy(&sha1_state_temp, &sha1_state, sizeof(hash_state));
AddTailToSha1(&sha1_state_temp, GetPlainFileName(ha->pStream->szFileName));
sha1_done(&sha1_state_temp, sha1_tail1);
memcpy(&sha1_state_temp, &sha1_state, sizeof(hash_state));
AddTailToSha1(&sha1_state_temp, "ARCHIVE");
sha1_done(&sha1_state_temp, sha1_tail2);
// Finalize the MD5 hash
FREEMEM(pbDigestBuffer);
return true;
}
// Creates a copy of hash table
static TMPQHash * CopyHashTable(TMPQArchive * ha)
{
TMPQHash * pHashTableCopy = ALLOCMEM(TMPQHash, ha->pHeader->dwHashTableSize);
if(pHashTableCopy != NULL)
memcpy(pHashTableCopy, ha->pHashTable, sizeof(TMPQHash) * ha->pHeader->dwHashTableSize);
return pHashTableCopy;
}
// register mod which overrides internal packages -----------------------------
//
PRIVATE
int SLm_RegisterModForce( char **modname )
{
char *name = modname[ 0 ];
//NOTE:
// mod_names[] is the global storage for the current mod names,
// declared in CON_EXT.C
// If mod_names[ 0 ] != NULL, a mod is currently active
if ( mod_numnames >= MAX_REGISTERED_MODS ) {
return FALSE;
}
mod_names[ mod_numnames ] = (char *) ALLOCMEM( strlen( name ) + 1 );
if ( mod_names[ mod_numnames ] == NULL ) {
return FALSE;
}
strcpy( mod_names[ mod_numnames ], name );
// allocate memory for "name/name.dat" string
char *packagename = (char *) ALLOCMEM( strlen( name ) * 2 + 6 );
if ( packagename == NULL ) {
return FALSE;
}
strcpy( packagename, name );
strcat( packagename, "/" );
strcat( packagename, name );
strcat( packagename, ".dat" );
if ( !SYS_RegisterPackage( packagename, 0, name ) ) {
MSGOUT( "CLI error: package registration failed (%s).\n", name );
MSGOUT( "CLI error: continuing without package.\n" );
}
mod_numnames++;
FREEMEM( packagename );
// set override flag
mod_override = TRUE;
return TRUE;
}
// exec startup script (usually boot.con, but also boot scripts of mods) ------
//
void ExecStartupScript( int echo )
{
// exec startup command script
char *startupscript = NULL;
// start normal or mod boot scripts
if ( mod_numnames > 0 ) {
ASSERT( mod_names[ 0 ] != NULL );
// if mod doesn't override our own packages, execute our boot.con too
if ( !mod_override ) {
//startupscript = PlayDemo ? demo_script_name : boot_script_name;
if(TheServer->GetServerIsMaster()){
startupscript = boot_script_master_name;
} else {
startupscript = boot_script_name;
}
ExecConsoleFile( startupscript, echo );
}
// afterwards, exec <modname>/boot.con for each registered mod
for ( int curmod = 0; curmod < mod_numnames; curmod++ ) {
ASSERT( mod_names[ curmod ] != NULL );
startupscript = (char *) ALLOCMEM(
strlen( mod_names[ curmod ] ) + 1 + strlen( boot_script_name ) );
if ( startupscript == NULL ) {
OUTOFMEM( 0 );
}
strcpy( startupscript, mod_names[ curmod ] );
strcat( startupscript, "/" );
strcat( startupscript, boot_script_name );
// must be done to ensure the file can be found independently of
// whether it is read from a package or from a real directory
char *path = SYSs_ProcessPathString( startupscript );
ExecConsoleFile( path, echo );
FREEMEM( startupscript );
startupscript = NULL;
}
} else {
// if no mod is active, we just exec boot.con
//startupscript = PlayDemo ? demo_script_name : boot_script_name;
if(TheServer->GetServerIsMaster()){
startupscript = boot_script_master_name;
} else {
startupscript = boot_script_name;
}
ExecConsoleFile( startupscript, echo );
}
}
// vapor trail constructor (class instantiation) ------------------------------
//
PRIVATE
void VaporTrailInstantiate( CustomObject *base )
{
ASSERT( base != NULL );
VaporTrail *vapor = (VaporTrail *) base;
// allocate memory for segments in one block
char *segmem = (char *) ALLOCMEM( ( sizeof( Vertex3 ) * 2 + sizeof( refframe_t ) ) * vapor->max_segments );
if ( segmem == NULL )
OUTOFMEM( "no mem for vapor trail." );
vapor->Trail_R = (Vertex3 *) ( segmem );
vapor->Trail_L = (Vertex3 *) ( segmem + sizeof( Vertex3 ) * vapor->max_segments );
vapor->alive = (refframe_t *) ( segmem + sizeof( Vertex3 ) * vapor->max_segments * 2 );
}
// register a new user-defined command ----------------------------------------
//
int CON_RegisterUserCommand( user_command_s *regcom )
{
//NOTE:
//CAVEAT:
// the supplied command string is not copied
// by this function. thus, the caller MUST ENSURE
// that this string is available indefinitely.
// (e.g., allocated statically.)
//NOTE:
// the commlen field need not be valid, it will be
// set by this function. (in the original struct!)
ASSERT( regcom != NULL );
ASSERT( regcom->command != NULL );
ASSERT( regcom->execute != NULL );
ASSERT( regcom->numparams >= 0 );
ASSERT( num_user_commands <= max_user_commands );
// expand table memory if already used up
if ( num_user_commands == max_user_commands ) {
// expand exponentially
int newtabsize = max_user_commands * 2;
// alloc new table
user_command_s *newlist = (user_command_s *) ALLOCMEM( sizeof( user_command_s ) * newtabsize );
if ( newlist == NULL ) {
ASSERT( 0 );
return FALSE;
}
// set new size
max_user_commands = newtabsize;
// move old table
memcpy( newlist, user_commands, sizeof( user_command_s ) * num_user_commands );
if ( user_commands != user_commands_default )
FREEMEM( user_commands );
user_commands = newlist;
}
// append new command
regcom->commlen = strlen( regcom->command );
ASSERT( num_user_commands < max_user_commands );
user_commands[ num_user_commands++ ] = *regcom;
return TRUE;
}
// acquire demos contained in package files -----------------------------------
//
int SYS_AcquirePackageDemos()
{
#ifdef PARSEC_CLIENT
// scan all registered packages
for ( unsigned int packid = 0; packid < (unsigned int)num_data_packages; packid++ ) {
// scan all items of this package
for ( unsigned int curit = 0; curit < package_numitems[ packid ]; curit++ ) {
// guard against overflow of registered demos
if ( num_registered_demos >= max_registered_demos )
break;
int demoid = num_registered_demos;
pfileinfo_s *item = &package_items[ packid ][ curit ];
// extension is mandatory
long len = strlen( item->file ) - 4;
// ASSERT( ( len >= 0 ) && ( len <= COMMAND_NAME_ALLOC_LEN ) );
if ( len < 0 )
continue;
// check demo extension
if ( strcmp( item->file + len, CON_FILE_COMPILED_EXTENSION ) != 0 )
continue;
// store demo name
if ( registered_demo_names[ demoid ] != NULL ) {
FREEMEM( registered_demo_names[ demoid ] );
registered_demo_names[ demoid ] = NULL;
}
registered_demo_names[ demoid ] = (char *) ALLOCMEM( len + 1 );
if ( registered_demo_names[ demoid ] == NULL )
continue;
strncpy( registered_demo_names[ demoid ], item->file, len );
registered_demo_names[ demoid ][ len ] = 0;
// convert to lower-case
strlwr( registered_demo_names[ demoid ] );
num_registered_demos++;
}
}
#endif // PARSEC_CLIENT
return TRUE;
}
// cache demo text as bitmap or textures --------------------------------------
//
PRIVATE
void InitDemoTextCache( int lineid )
{
ASSERT(0);
ASSERT( (dword)lineid < DEMOTEXT_NUM_LINES );
// size of buffer for string blit
size_t bufsize = Screen_Width * Screen_BytesPerPixel * 80;
//NOTE:
// using Screen_Pitch instead of ( Screen_Width * Screen_BytesPerPixel )
// doesn't always work here because on a Voodoo3 Screen_Pitch will be set
// to 2048, as on all other Voodoos. this is too low for resolutions
// higher than 1024x768.
demotext_fontmem[ lineid ] = (char *) ALLOCMEM( bufsize );
if ( demotext_fontmem[ lineid ] == NULL )
OUTOFMEM( 0 );
memset( demotext_fontmem[ lineid ], 0, bufsize );
int charsetid = demotext_charset_id[ lineid ];
D_SetWStrContext( CharsetInfo[ charsetid ].charsetpointer,
CharsetInfo[ charsetid ].geompointer,
demotext_fontmem[ lineid ],
CharsetInfo[ charsetid ].width,
CharsetInfo[ charsetid ].height );
if ( demotext_capitals[ lineid ] ) {
strupr( demotext_text[ lineid ] );
} else {
strlwr( demotext_text[ lineid ] );
}
int swidth = D_GetPStringWidth( demotext_text[ lineid ] );
if ( swidth <= Screen_Width ) {
// D_WritePString( demotext_text[ lineid ], (Screen_Width-swidth)/2, 0 );
} else {
MSGOUT( "string too long." );
}
// split up bitmap into appropriately sized textures if necessary
if ( VidInfo_UseIterForDemoTexts ) {
CreateBitmapTextures( &demotext_fontmem[ lineid ] );
}
}
// read palette files into buffer ---------------------------------------------
//
PRIVATE
void ReadPalettes()
{
// exit if nothing to read
if ( NumLoadedPalettes == 0 )
PANIC( "no palette defined." );
if ( ( PaletteMem = (char *) ALLOCMEM( PALETTE_SIZE * NumLoadedPalettes ) ) == NULL )
OUTOFMEM( no_palette_mem );
if ( display_info ) {
MSGPUT( "Loading palettes" );
if ( show_palettes_loaded ) {
MSGOUT( ":\n" );
} else {
MSGPUT( "..." );
}
}
// load all palettes
size_t readofs = 0;
for ( int pid = 0; pid < NumLoadedPalettes; pid++ ) {
if ( display_info && !show_palettes_loaded )
MSGPUT( "." );
FILE *fp = SYS_fopen( palette_fnames[ pid ], "rb" );
if ( fp == NULL )
FERROR( palette_not_found, palette_fnames[ pid ] );
if ( display_info && show_palettes_loaded ) {
MSGOUT( "loading \"%s\" (palette)\n", palette_fnames[ pid ] );
}
size_t bytesread = SYS_fread( PaletteMem + readofs, 1, PALETTE_SIZE, fp );
if ( bytesread != PALETTE_SIZE )
FERROR( palette_readerror, palette_fnames[ pid ] );
readofs += PALETTE_SIZE;
SYS_fclose( fp );
}
if ( display_info ) {
MSGOUT( "done.\n" );
}
}
// write actual file data into output package ---------------------------------
//
PRIVATE
int WritePackageData( FILE *fp, list_item_s *listitems, int numitems )
{
ASSERT( fp != NULL );
ASSERT( listitems != NULL );
ASSERT( numitems > 0 );
for ( int curit = 0; curit < numitems; curit++ ) {
PrintfNoNL( "." );
FILE *itfp = fopen( listitems[ curit ].file, "rb" );
if ( itfp == NULL ) {
Err_Printf( "\ndata file \"%s\" not found: %s\n",
listitems[ curit ].file, strerror( errno ) );
return FALSE;
}
char *filedata = (char *) ALLOCMEM( listitems[ curit ].flength );
if ( filedata == NULL ) {
fclose( itfp );
return FALSE;
}
size_t bytesread = fread( filedata, 1, listitems[ curit ].flength, itfp );
if ( bytesread != listitems[ curit ].flength ) {
FREEMEM( filedata );
fclose( itfp );
return FALSE;
}
size_t byteswritten = fwrite( filedata, 1, listitems[ curit ].flength, fp );
if ( byteswritten != listitems[ curit ].flength ) {
FREEMEM( filedata );
fclose( itfp );
return FALSE;
}
fclose( itfp );
FREEMEM( filedata );
}
return TRUE;
}
// read sample after determining its format -----------------------------------
//
sample_s *SND_ReadSample( sampleinfo_s *pSampleInfo )
{
ASSERT( pSampleInfo != NULL );
// determine sound type from extension
char *fext = SYSs_ScanToExtension( pSampleInfo->file );
sample_s *pSample = (sample_s *) ALLOCMEM(sizeof(sample_s));
pSample->format = SAMPLEFORMAT_INVALID;
// pSample->samplebuffer;
if ( stricmp( fext, snd_ext_wav ) == 0 ) {
pSample->format = SAMPLEFORMAT_WAV;
WAV_ReadSample(pSampleInfo,pSample);
}
return pSample;
}
// allocate received packets chain (head node) --------------------------------
//
PRIVATE
int AllocPacketsChain()
{
ASSERT( ReceivedPacketsChain == NULL );
ReceivedPacketsChain = (PacketChainHead *) ALLOCMEM( sizeof( PacketChainHead ) );
if ( ReceivedPacketsChain == NULL ) {
if ( TextModeActive ) {
fprintf( stderr, pchain_alloc_error );
fprintf( stderr, net_game_unavail );
} else {
OUTOFMEM( 0 );
}
return FALSE;
}
ReceivedPacketsChain->nextblock = NULL;
ReceivedPacketsChain->chainlength = 0;
return TRUE;
}
// register new shader --------------------------------------------------------
//
int RegisterShader( shader_s *shader )
{
ASSERT( shader != NULL );
if ( num_registered_shaders >= MAX_NUM_REGISTERED_SHADERS )
return FALSE;
// name is mandatory
if ( shader->name == NULL )
return FALSE;
dword shaderid = num_registered_shaders;
// check for already registered shader of same name
if ( FetchShaderByName( shader->name, &shaderid ) != NULL ) {
if ( !AUX_ENABLE_SHADER_OVERLOADING ) {
return FALSE;
}
} else {
// allocate new shader name
char *name = (char *) ALLOCMEM( strlen( shader->name ) + 1 );
if ( name == NULL )
OUTOFMEM( 0 );
strcpy( name, shader->name );
ASSERT( registered_shaders[ shaderid ].name == NULL );
registered_shaders[ shaderid ].name = name;
num_registered_shaders++;
}
// store shader info
registered_shaders[ shaderid ].iter = shader->iter;
registered_shaders[ shaderid ].flags = shader->flags;
registered_shaders[ shaderid ].texanim = shader->texanim;
registered_shaders[ shaderid ].facecolor = shader->facecolor;
registered_shaders[ shaderid ].colanim = shader->colanim;
registered_shaders[ shaderid ].colflags = shader->colflags;
return TRUE;
}
static void build_common_binary_response_fields(struct request_state* req)
{
if (!req->bin_hdr_response)
{
req->bin_hdr_response = (struct memcache_hdr_res*)
ALLOCMEM(MEMCACHED_PKT_HDR_RES_LEN, GFP_KERNEL);
}
req->bin_hdr_response->magic = MEMCACHED_MAGIC_RES;
req->bin_hdr_response->opcode = req->cmd;
req->bin_hdr_response->len_key = 0L;
req->bin_hdr_response->len_extras = 0L;
req->bin_hdr_response->datatype = 0L;
req->bin_hdr_response->opaque = 0L;
req->bin_hdr_response->cas = 0L;
req->bin_hdr_response->status = 0L; // overridden later if necessary
req->bin_hdr_response->len_body = 0L;
return;
}
/*************
* DESCRIPTION: read the points
* INPUT: data handler data
* cn iff context node
* OUTPUT: error string
*************/
static char *ReadPoints(HANDLER_DATA *data, struct ContextNode *cn)
{
int count;
// get point count (each point has a size of 12 bytes)
count = (cn->cn_Size)/sizeof(VECTOR);
// Allocate memory
data->pointcount = count;
data->points = ALLOCMEM(VECTOR, count);
if (!data->points)
return errors[ERR_MEM];
// Read points
if(!ReadFloat(data->iff, (float*)data->points, count*3))
return errors[ERR_LWOBFILE];
return NULL;
}
// read binary demo file as one huge block ------------------------------------
//
PRIVATE
int DEMO_BinaryReadDemo( FILE *fp, int infomsgs, int errormsgs )
{
ASSERT( fp != NULL );
ASSERT( demo_data == NULL );
// get file size
if ( SYS_fseek( fp, 0, SEEK_END ) != 0 ) {
return FALSE;
}
size_t demosize = SYS_ftell( fp );
if ( SYS_fseek( fp, 0, SEEK_SET ) != 0 ) {
return FALSE;
}
// check for demo header and parse it if present
size_t headersize = DEMO_ParseDemoHeader( fp, -1, infomsgs );
if ( demosize >= headersize ) {
demosize -= headersize;
}
if ( demosize == 0 ) {
return FALSE;
}
// allocate mem for demo data
demo_data = (char *) ALLOCMEM( demosize );
if ( demo_data == NULL ) {
if ( errormsgs )
CON_AddLine( "no mem for demo replay." );
return FALSE;
}
// read entire file into single memory block
if ( SYS_fread( demo_data, 1, demosize, fp ) != demosize ) {
if ( errormsgs )
CON_AddLine( "error reading demo file." );
return FALSE;
}
return TRUE;
}
int ub_core_run(void)
{
int res;
struct request_state* req = (struct request_state*)
ALLOCMEM(sizeof(struct request_state), GFP_KERNEL);
#ifdef __KERNEL__
allow_signal(SIGKILL | SIGSTOP);
#endif
if (!req
#ifdef __KERNEL__
|| ksize(req) < sizeof(struct request_state)
#endif
)
return -ENOMEM;
memset(req, 0, sizeof(struct request_state));
if ((res = udpserver_start(req)) < 0)
{
#ifdef DEBUG
PRINTARGS(
#ifdef __KERNEL__
KERN_ERR
#endif
"Something went wrong starting the UDP server %d\n", res);
#endif
FREEMEM(req);
return res;
}
res = process_slowpath(req);
udpserver_exit();
if (req)
{
FREEMEM(req);
req = NULL;
}
return res;
}
FRAME *
fr_create(int entries, int size)
{
FRAME *tab;
if (size < sizeof(char **))
size = sizeof(char **); /* ensure size for free list */
if ((tab = ALLOCMEM(FRAME, 1)) == 0) {
return 0;
}
tab->nentry = entries;
tab->nsize = size;
if ((tab->frbuf = MALLOCMEM(entries * size)) == 0) {
FREEMEM(tab);
return 0;
}
init_list(tab);
tab->next = 0; /* continuation block */
return tab;
}
static int ApplyMpqPatch_COPY(
TMPQFile * hf,
TPatchHeader * pPatchHeader)
{
LPBYTE pbNewFileData;
DWORD cbNewFileData;
// Allocate space for new file data
cbNewFileData = pPatchHeader->dwXfrmBlockSize - SIZE_OF_XFRM_HEADER;
pbNewFileData = ALLOCMEM(BYTE, cbNewFileData);
if(pbNewFileData == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
// Copy the patch data as-is
memcpy(pbNewFileData, (LPBYTE)pPatchHeader + sizeof(TPatchHeader), cbNewFileData);
// Free the old file data
FREEMEM(hf->pbFileData);
// Put the new file data there
hf->pbFileData = pbNewFileData;
hf->cbFileData = cbNewFileData;
return ERROR_SUCCESS;
}
bool WINAPI SFileCreateArchive(const char * szMpqName, DWORD dwFlags, DWORD dwMaxFileCount, HANDLE * phMpq)
{
TFileStream * pStream = NULL; // File stream
TMPQArchive * ha = NULL; // MPQ archive handle
ULONGLONG MpqPos = 0; // Position of MPQ header in the file
HANDLE hMpq = NULL;
USHORT wFormatVersion = MPQ_FORMAT_VERSION_1;
DWORD dwBlockTableSize = 0; // Initial block table size
DWORD dwHashTableSize = 0;
int nError = ERROR_SUCCESS;
// Check the parameters, if they are valid
if(szMpqName == NULL || *szMpqName == 0 || phMpq == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return false;
}
// One time initialization of MPQ cryptography
InitializeMpqCryptography();
// We verify if the file already exists and if it's a MPQ archive.
// If yes, we won't allow to overwrite it.
if(SFileOpenArchive(szMpqName, 0, dwFlags, &hMpq))
{
SFileCloseArchive(hMpq);
SetLastError(ERROR_ALREADY_EXISTS);
return false;
}
//
// At this point, we have to create the archive.
// - If the file exists, convert it to MPQ archive.
// - If the file doesn't exist, create new empty file
//
pStream = FileStream_OpenFile(szMpqName, true);
if(pStream == NULL)
{
pStream = FileStream_CreateFile(szMpqName);
if(pStream == NULL)
return false;
}
// Decide what format to use
wFormatVersion = (USHORT)((dwFlags & MPQ_CREATE_ARCHIVE_VMASK) >> 16);
if(wFormatVersion > MPQ_FORMAT_VERSION_4)
{
SetLastError(ERROR_INVALID_PARAMETER);
return false;
}
// Increment the maximum amount of files to have space
// for listfile and attributes file
if(dwFlags & MPQ_CREATE_ATTRIBUTES)
dwMaxFileCount++;
dwMaxFileCount++;
// If file count is not zero, initialize the hash table size
dwHashTableSize = GetHashTableSizeForFileCount(dwMaxFileCount);
// Retrieve the file size and round it up to 0x200 bytes
FileStream_GetSize(pStream, MpqPos);
MpqPos = (MpqPos + 0x1FF) & (ULONGLONG)0xFFFFFFFFFFFFFE00ULL;
if(!FileStream_SetSize(pStream, MpqPos))
nError = GetLastError();
#ifdef _DEBUG
// Debug code, used for testing StormLib
// dwBlockTableSize = dwHashTableSize * 2;
#endif
// Create the archive handle
if(nError == ERROR_SUCCESS)
{
if((ha = ALLOCMEM(TMPQArchive, 1)) == NULL)
nError = ERROR_NOT_ENOUGH_MEMORY;
}
// Fill the MPQ archive handle structure
if(nError == ERROR_SUCCESS)
{
memset(ha, 0, sizeof(TMPQArchive));
ha->pStream = pStream;
ha->dwSectorSize = (wFormatVersion >= MPQ_FORMAT_VERSION_3) ? 0x4000 : 0x1000;
ha->UserDataPos = MpqPos;
ha->MpqPos = MpqPos;
ha->pHeader = (TMPQHeader *)ha->HeaderData;
ha->dwMaxFileCount = dwMaxFileCount;
ha->dwFileTableSize = 0;
ha->dwFileFlags1 = MPQ_FILE_ENCRYPTED | MPQ_FILE_COMPRESS | MPQ_FILE_REPLACEEXISTING;
ha->dwFileFlags2 = MPQ_FILE_ENCRYPTED | MPQ_FILE_COMPRESS | MPQ_FILE_REPLACEEXISTING;
ha->dwFlags = 0;
// Setup the attributes
if(dwFlags & MPQ_CREATE_ATTRIBUTES)
ha->dwAttrFlags = MPQ_ATTRIBUTE_CRC32 | MPQ_ATTRIBUTE_FILETIME | MPQ_ATTRIBUTE_MD5;
pStream = NULL;
}
// Fill the MPQ header
if(nError == ERROR_SUCCESS)
{
TMPQHeader * pHeader = ha->pHeader;
// Fill the MPQ header
memset(pHeader, 0, sizeof(ha->HeaderData));
pHeader->dwID = ID_MPQ;
pHeader->dwHeaderSize = MpqHeaderSizes[wFormatVersion];
pHeader->dwArchiveSize = pHeader->dwHeaderSize + dwHashTableSize * sizeof(TMPQHash);
pHeader->wFormatVersion = wFormatVersion;
pHeader->wSectorSize = GetSectorSizeShift(ha->dwSectorSize);
pHeader->dwHashTablePos = pHeader->dwHeaderSize;
pHeader->dwHashTableSize = dwHashTableSize;
pHeader->dwBlockTablePos = pHeader->dwHashTablePos + dwHashTableSize * sizeof(TMPQHash);
pHeader->dwBlockTableSize = dwBlockTableSize;
// For MPQs version 4 and higher, we set the size of raw data block
// for calculating MD5
if(wFormatVersion >= MPQ_FORMAT_VERSION_4)
pHeader->dwRawChunkSize = 0x4000;
// Write the naked MPQ header
nError = WriteNakedMPQHeader(ha);
//
// Note: Don't recalculate position of MPQ tables at this point.
// We merely set a flag that indicates that the MPQ tables
// have been changed, and SaveMpqTables will do the work when closing the archive.
//
ha->dwFlags |= MPQ_FLAG_CHANGED;
}
// Create initial hash table
if(nError == ERROR_SUCCESS)
{
nError = CreateHashTable(ha, dwHashTableSize);
}
// Create initial HET table, if the caller required an MPQ format 3.0 or newer
if(nError == ERROR_SUCCESS && wFormatVersion >= MPQ_FORMAT_VERSION_3)
{
ha->pHetTable = CreateHetTable(ha->dwMaxFileCount, 0x40, true);
if(ha->pHetTable == NULL)
nError = ERROR_NOT_ENOUGH_MEMORY;
}
// Create initial file table
if(nError == ERROR_SUCCESS)
{
ha->pFileTable = ALLOCMEM(TFileEntry, dwMaxFileCount);
if(ha->pFileTable != NULL)
memset(ha->pFileTable, 0x00, sizeof(TFileEntry) * dwMaxFileCount);
else
nError = ERROR_NOT_ENOUGH_MEMORY;
}
// Cleanup : If an error, delete all buffers and return
if(nError != ERROR_SUCCESS)
{
FileStream_Close(pStream);
FreeMPQArchive(ha);
SetLastError(nError);
ha = NULL;
}
// Return the values
*phMpq = (HANDLE)ha;
return (nError == ERROR_SUCCESS);
}
