mirror of
https://github.com/w23/xash3d-fwgs
synced 2024-12-17 14:59:57 +01:00
1088 lines
27 KiB
C
1088 lines
27 KiB
C
/*
|
|
hpak.c - custom user package to send other clients
|
|
Copyright (C) 2010 Uncle Mike
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "common.h"
|
|
#include "filesystem.h"
|
|
|
|
#define HPAK_MAX_ENTRIES 0x8000
|
|
#define HPAK_MIN_SIZE (1 * 1024)
|
|
#define HPAK_MAX_SIZE (128 * 1024)
|
|
|
|
typedef struct hash_pack_queue_s
|
|
{
|
|
char *name;
|
|
resource_t resource;
|
|
size_t size;
|
|
void *data;
|
|
struct hash_pack_queue_s *next;
|
|
} hash_pack_queue_t;
|
|
|
|
convar_t *hpk_maxsize;
|
|
hash_pack_queue_t *gp_hpak_queue = NULL;
|
|
hpak_header_t hash_pack_header;
|
|
hpak_info_t hash_pack_info;
|
|
|
|
const char *HPAK_TypeFromIndex( int type )
|
|
{
|
|
switch( type )
|
|
{
|
|
case t_sound: return "decal";
|
|
case t_skin: return "skin";
|
|
case t_model: return "model";
|
|
case t_decal: return "decal";
|
|
case t_generic: return "generic";
|
|
case t_eventscript: return "event";
|
|
case t_world: return "map";
|
|
}
|
|
return "?";
|
|
}
|
|
|
|
static void HPAK_AddToQueue( const char *name, resource_t *pResource, void *data, file_t *f )
|
|
{
|
|
hash_pack_queue_t *p;
|
|
|
|
p = Z_Malloc( sizeof( hash_pack_queue_t ));
|
|
p->name = copystring( name );
|
|
p->resource = *pResource;
|
|
p->size = pResource->nDownloadSize;
|
|
p->data = Z_Malloc( p->size );
|
|
|
|
if( data != NULL ) memcpy( p->data, data, p->size );
|
|
else if( f != NULL ) FS_Read( f, p->data, p->size );
|
|
else Host_Error( "HPAK_AddToQueue: data == NULL.\n" );
|
|
|
|
p->next = gp_hpak_queue;
|
|
gp_hpak_queue = p;
|
|
}
|
|
|
|
void HPAK_FlushHostQueue( void )
|
|
{
|
|
hash_pack_queue_t *p;
|
|
|
|
for( p = gp_hpak_queue; p != NULL; p = gp_hpak_queue )
|
|
{
|
|
gp_hpak_queue = p->next;
|
|
HPAK_AddLump( false, p->name, &p->resource, p->data, NULL );
|
|
freestring( p->name );
|
|
Mem_Free( p->data );
|
|
Mem_Free( p );
|
|
}
|
|
gp_hpak_queue = NULL;
|
|
}
|
|
|
|
void HPAK_CreatePak( const char *filename, resource_t *pResource, byte *pData, file_t *fin )
|
|
{
|
|
int filelocation;
|
|
string pakname;
|
|
byte md5[16];
|
|
file_t *fout;
|
|
MD5Context_t ctx;
|
|
|
|
if( !COM_CheckString( filename ))
|
|
return;
|
|
|
|
if(( fin != NULL && pData != NULL ) || ( fin == NULL && pData == NULL ))
|
|
return;
|
|
|
|
Q_strncpy( pakname, filename, sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
|
|
Con_Printf( "creating HPAK %s.\n", pakname );
|
|
|
|
fout = FS_Open( pakname, "wb", false );
|
|
if( !fout )
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_CreatePak: can't write %s.\n", pakname );
|
|
return;
|
|
}
|
|
|
|
// let's hash it.
|
|
memset( &ctx, 0, sizeof( MD5Context_t ));
|
|
MD5Init( &ctx );
|
|
|
|
if( pData == NULL )
|
|
{
|
|
byte *temp;
|
|
|
|
// there are better ways
|
|
filelocation = FS_Tell( fin );
|
|
temp = Z_Malloc( pResource->nDownloadSize );
|
|
FS_Read( fin, temp, pResource->nDownloadSize );
|
|
FS_Seek( fin, filelocation, SEEK_SET );
|
|
MD5Update( &ctx, temp, pResource->nDownloadSize );
|
|
Mem_Free( temp );
|
|
}
|
|
else
|
|
{
|
|
MD5Update( &ctx, pData, pResource->nDownloadSize );
|
|
}
|
|
|
|
MD5Final( md5, &ctx );
|
|
|
|
if( memcmp( md5, pResource->rgucMD5_hash, 16 ))
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_CreatePak: bad checksum for %s. Ignored\n", pakname );
|
|
return;
|
|
}
|
|
|
|
hash_pack_header.ident = IDHPAKHEADER;
|
|
hash_pack_header.version = IDHPAK_VERSION;
|
|
hash_pack_header.infotableofs = 0;
|
|
|
|
FS_Write( fout, &hash_pack_header, sizeof( hash_pack_header ));
|
|
|
|
hash_pack_info.count = 1;
|
|
hash_pack_info.entries = Z_Malloc( sizeof( hpak_lump_t ));
|
|
hash_pack_info.entries[0].resource = *pResource;
|
|
hash_pack_info.entries[0].filepos = FS_Tell( fout );
|
|
hash_pack_info.entries[0].disksize = pResource->nDownloadSize;
|
|
|
|
if( pData == NULL )
|
|
{
|
|
FS_FileCopy( fout, fin, hash_pack_info.entries[0].disksize );
|
|
}
|
|
else
|
|
{
|
|
FS_Write( fout, pData, hash_pack_info.entries[0].disksize );
|
|
}
|
|
|
|
filelocation = FS_Tell( fout );
|
|
FS_Write( fout, &hash_pack_info.count, sizeof( hash_pack_info.count ));
|
|
FS_Write( fout, &hash_pack_info.entries[0], sizeof( hpak_lump_t ));
|
|
|
|
if( hash_pack_info.entries )
|
|
Mem_Free( hash_pack_info.entries );
|
|
memset( &hash_pack_info, 0, sizeof( hpak_info_t ));
|
|
|
|
hash_pack_header.infotableofs = filelocation;
|
|
FS_Seek( fout, 0, SEEK_SET );
|
|
FS_Write( fout, &hash_pack_header, sizeof( hpak_header_t ));
|
|
FS_Close( fout );
|
|
}
|
|
|
|
static qboolean HPAK_FindResource( hpak_info_t *hpk, byte *hash, resource_t *pResource )
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < hpk->count; i++ )
|
|
{
|
|
if( !memcmp( hpk->entries[i].resource.rgucMD5_hash, hash, 16 ))
|
|
{
|
|
if( pResource )
|
|
*pResource = hpk->entries[i].resource;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource, byte *pData, file_t *pFile )
|
|
{
|
|
int i, j, position, length;
|
|
hpak_lump_t *pCurrentEntry = NULL;
|
|
string srcname, dstname;
|
|
hpak_info_t srcpak, dstpak;
|
|
file_t *file_src;
|
|
file_t *file_dst;
|
|
byte md5[16];
|
|
MD5Context_t ctx;
|
|
|
|
if( pData == NULL && pFile == NULL )
|
|
return;
|
|
|
|
if( pResource->nDownloadSize < HPAK_MIN_SIZE || pResource->nDownloadSize > HPAK_MAX_SIZE )
|
|
{
|
|
Con_Printf( S_ERROR "%s: invalid size %s\n", name, Q_pretifymem( pResource->nDownloadSize, 2 ));
|
|
return;
|
|
}
|
|
|
|
// hash it
|
|
memset( &ctx, 0, sizeof( MD5Context_t ));
|
|
MD5Init( &ctx );
|
|
|
|
if( pData == NULL )
|
|
{
|
|
byte *temp;
|
|
|
|
// there are better ways
|
|
position = FS_Tell( pFile );
|
|
temp = Z_Malloc( pResource->nDownloadSize );
|
|
FS_Read( pFile, temp, pResource->nDownloadSize );
|
|
FS_Seek( pFile, position, SEEK_SET );
|
|
MD5Update( &ctx, temp, pResource->nDownloadSize );
|
|
Mem_Free( temp );
|
|
}
|
|
else
|
|
{
|
|
MD5Update( &ctx, pData, pResource->nDownloadSize );
|
|
}
|
|
|
|
MD5Final( md5, &ctx );
|
|
|
|
if( memcmp( md5, pResource->rgucMD5_hash, 16 ))
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_AddLump: bad checksum for %s. Ignored\n", pResource->szFileName );
|
|
return;
|
|
}
|
|
|
|
if( bUseQueue )
|
|
{
|
|
HPAK_AddToQueue( name, pResource, pData, pFile );
|
|
return;
|
|
}
|
|
|
|
Q_strncpy( srcname, name, sizeof( srcname ));
|
|
COM_ReplaceExtension( srcname, ".hpk" );
|
|
|
|
file_src = FS_Open( srcname, "rb", false );
|
|
|
|
if( !file_src )
|
|
{
|
|
// just create new pack
|
|
HPAK_CreatePak( name, pResource, pData, pFile );
|
|
return;
|
|
}
|
|
|
|
Q_strncpy( dstname, srcname, sizeof( dstname ));
|
|
COM_ReplaceExtension( dstname, ".hp2" );
|
|
|
|
file_dst = FS_Open( dstname, "wb", false );
|
|
|
|
if( !file_dst )
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_AddLump: couldn't open %s.\n", srcname );
|
|
FS_Close( file_src );
|
|
return;
|
|
}
|
|
|
|
// load headers
|
|
FS_Read( file_src, &hash_pack_header, sizeof( hpak_header_t ));
|
|
|
|
if( hash_pack_header.version != IDHPAK_VERSION )
|
|
{
|
|
// we don't check the HPAK bit for some reason.
|
|
Con_DPrintf( S_ERROR "HPAK_AddLump: %s does not have a valid header.\n", srcname );
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
return;
|
|
}
|
|
|
|
length = FS_FileLength( file_src );
|
|
FS_Seek( file_src, 0, SEEK_SET ); // rewind to start of file
|
|
FS_FileCopy( file_dst, file_src, length );
|
|
|
|
FS_Seek( file_src, hash_pack_header.infotableofs, SEEK_SET );
|
|
FS_Read( file_src, &srcpak.count, sizeof( srcpak.count ));
|
|
|
|
if( srcpak.count < 1 || srcpak.count > HPAK_MAX_ENTRIES )
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_AddLump: %s contain too many lumps.\n", srcname );
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
return;
|
|
}
|
|
|
|
// load the data
|
|
srcpak.entries = Z_Malloc( sizeof( hpak_lump_t ) * srcpak.count );
|
|
FS_Read( file_src, srcpak.entries, sizeof( hpak_lump_t ) * srcpak.count );
|
|
|
|
// check if already exists
|
|
if( HPAK_FindResource( &srcpak, pResource->rgucMD5_hash, NULL ))
|
|
{
|
|
Z_Free( srcpak.entries );
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
FS_Delete( dstname );
|
|
return;
|
|
}
|
|
|
|
// make a new container
|
|
dstpak.count = srcpak.count + 1;
|
|
dstpak.entries = Z_Malloc( sizeof( hpak_lump_t ) * dstpak.count );
|
|
memcpy( dstpak.entries, srcpak.entries, srcpak.count );
|
|
|
|
for( i = 0; i < srcpak.count; i++ )
|
|
{
|
|
if( memcmp( md5, srcpak.entries[i].resource.rgucMD5_hash, 16 ))
|
|
{
|
|
pCurrentEntry = &dstpak.entries[i];
|
|
|
|
for( j = i; j < srcpak.count; j++ )
|
|
dstpak.entries[j + 1] = srcpak.entries[j];
|
|
}
|
|
}
|
|
|
|
if( !pCurrentEntry )
|
|
pCurrentEntry = &dstpak.entries[dstpak.count-1];
|
|
|
|
memset( pCurrentEntry, 0, sizeof( hpak_lump_t ));
|
|
FS_Seek( file_dst, hash_pack_header.infotableofs, SEEK_SET );
|
|
pCurrentEntry->resource = *pResource;
|
|
pCurrentEntry->filepos = FS_Tell( file_dst );
|
|
pCurrentEntry->disksize = pResource->nDownloadSize;
|
|
|
|
if( !pData ) FS_FileCopy( file_dst, file_src, pCurrentEntry->disksize );
|
|
else FS_Write( file_dst, pData, pCurrentEntry->disksize );
|
|
|
|
hash_pack_header.infotableofs = FS_Tell( file_dst );
|
|
FS_Write( file_dst, &dstpak.count, sizeof( dstpak.count ));
|
|
|
|
for( i = 0; i < dstpak.count; i++ )
|
|
{
|
|
FS_Write( file_dst, &dstpak.entries[i], sizeof( hpak_lump_t ));
|
|
}
|
|
|
|
// finalize
|
|
if( srcpak.entries )
|
|
Mem_Free( srcpak.entries );
|
|
if( dstpak.entries )
|
|
Mem_Free( dstpak.entries );
|
|
|
|
FS_Seek( file_dst, 0, SEEK_SET );
|
|
FS_Write( file_dst, &hash_pack_header, sizeof( hpak_header_t ));
|
|
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
|
|
FS_Delete( srcname );
|
|
FS_Rename( dstname, srcname );
|
|
}
|
|
|
|
static qboolean HPAK_Validate( const char *filename, qboolean quiet )
|
|
{
|
|
file_t *f;
|
|
hpak_lump_t *dataDir;
|
|
hpak_header_t hdr;
|
|
byte *dataPak;
|
|
int i, num_lumps;
|
|
MD5Context_t MD5_Hash;
|
|
string pakname;
|
|
resource_t *pRes;
|
|
byte md5[16];
|
|
|
|
if( quiet ) HPAK_FlushHostQueue();
|
|
|
|
// not an error - just flush queue
|
|
if( !COM_CheckString( filename ) )
|
|
return true;
|
|
|
|
Q_strncpy( pakname, filename, sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
|
|
f = FS_Open( pakname, "rb", false );
|
|
if( !f )
|
|
{
|
|
Con_DPrintf( S_ERROR "Couldn't find %s.\n", pakname );
|
|
return true;
|
|
}
|
|
|
|
if( !quiet ) Con_Printf( "Validating %s\n", pakname );
|
|
|
|
FS_Read( f, &hdr, sizeof( hdr ));
|
|
if( hdr.ident != IDHPAKHEADER || hdr.version != IDHPAK_VERSION )
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_ValidatePak: %s does not have a valid HPAK header.\n", pakname );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
FS_Seek( f, hdr.infotableofs, SEEK_SET );
|
|
FS_Read( f, &num_lumps, sizeof( num_lumps ));
|
|
|
|
if( num_lumps < 1 || num_lumps > MAX_FILES_IN_WAD )
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_ValidatePak: %s has too many lumps %u.\n", pakname, num_lumps );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
if( !quiet ) Con_Printf( "# of Entries: %i\n", num_lumps );
|
|
|
|
dataDir = Z_Malloc( sizeof( hpak_lump_t ) * num_lumps );
|
|
FS_Read( f, dataDir, sizeof( hpak_lump_t ) * num_lumps );
|
|
|
|
if( !quiet ) Con_Printf( "# Type Size FileName : MD5 Hash\n" );
|
|
|
|
for( i = 0; i < num_lumps; i++ )
|
|
{
|
|
if( dataDir[i].disksize < 1 || dataDir[i].disksize > 131071 )
|
|
{
|
|
// odd max size
|
|
Con_DPrintf( S_ERROR "HPAK_ValidatePak: lump %i has invalid size %s\n", i, Q_pretifymem( dataDir[i].disksize, 2 ));
|
|
Mem_Free( dataDir );
|
|
FS_Close(f);
|
|
return false;
|
|
}
|
|
|
|
dataPak = Z_Malloc( dataDir[i].disksize );
|
|
FS_Seek( f, dataDir[i].filepos, SEEK_SET );
|
|
FS_Read( f, dataPak, dataDir[i].disksize );
|
|
|
|
memset( &MD5_Hash, 0, sizeof( MD5Context_t ));
|
|
MD5Init( &MD5_Hash );
|
|
MD5Update( &MD5_Hash, dataPak, dataDir[i].disksize );
|
|
MD5Final( md5, &MD5_Hash );
|
|
|
|
pRes = &dataDir[i].resource;
|
|
|
|
Con_Printf( "%i: %s %s %s: ", i, HPAK_TypeFromIndex( pRes->type ),
|
|
Q_pretifymem( pRes->nDownloadSize, 2 ), pRes->szFileName );
|
|
|
|
if( memcmp( md5, pRes->rgucMD5_hash, 0x10 ))
|
|
{
|
|
if( quiet )
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_ValidatePak: %s has invalid checksum.\n", pakname );
|
|
Mem_Free( dataPak );
|
|
Mem_Free( dataDir );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
else Con_DPrintf( S_ERROR "failed\n" );
|
|
}
|
|
else
|
|
{
|
|
if( !quiet ) Con_Printf( "OK\n" );
|
|
}
|
|
|
|
// at this point, it's passed our checks.
|
|
Mem_Free( dataPak );
|
|
}
|
|
|
|
Mem_Free( dataDir );
|
|
FS_Close( f );
|
|
return true;
|
|
}
|
|
|
|
void HPAK_ValidatePak( const char *filename )
|
|
{
|
|
HPAK_Validate( filename, true );
|
|
}
|
|
|
|
void HPAK_CheckIntegrity( const char *filename )
|
|
{
|
|
string pakname;
|
|
|
|
if( !COM_CheckString( filename ) )
|
|
return;
|
|
|
|
Q_strncpy( pakname, filename, sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
|
|
HPAK_ValidatePak( pakname );
|
|
}
|
|
|
|
void HPAK_CheckSize( const char *filename )
|
|
{
|
|
string pakname;
|
|
int maxsize;
|
|
|
|
maxsize = hpk_maxsize->value;
|
|
if( maxsize <= 0 ) return;
|
|
|
|
if( !COM_CheckString( filename ) )
|
|
return;
|
|
|
|
Q_strncpy( pakname, filename, sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
|
|
if( FS_FileSize( pakname, false ) > ( maxsize * 1000000 ))
|
|
{
|
|
Con_Printf( "Server: Size of %s > %f MB, deleting.\n", filename, hpk_maxsize->value );
|
|
Log_Printf( "Server: Size of %s > %f MB, deleting.\n", filename, hpk_maxsize->value );
|
|
FS_Delete( filename );
|
|
}
|
|
}
|
|
|
|
qboolean HPAK_ResourceForHash( const char *filename, byte *hash, resource_t *pResource )
|
|
{
|
|
hpak_info_t directory;
|
|
hpak_header_t header;
|
|
string pakname;
|
|
qboolean bFound;
|
|
file_t *f;
|
|
hash_pack_queue_t *p;
|
|
|
|
if( !COM_CheckString( filename ))
|
|
return false;
|
|
|
|
for( p = gp_hpak_queue; p != NULL; p = p->next )
|
|
{
|
|
if( !Q_stricmp( p->name, filename ) && !memcmp( p->resource.rgucMD5_hash, hash, 16 ))
|
|
{
|
|
if( pResource != NULL )
|
|
*pResource = p->resource;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Q_strncpy( pakname, filename, sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
|
|
f = FS_Open( pakname, "rb", false );
|
|
if( !f ) return false;
|
|
|
|
FS_Read( f, &header, sizeof( header ));
|
|
|
|
if( header.ident != IDHPAKHEADER )
|
|
{
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
if( header.version != IDHPAK_VERSION )
|
|
{
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
FS_Seek( f, header.infotableofs, SEEK_SET );
|
|
FS_Read( f, &directory.count, sizeof( directory.count ));
|
|
|
|
if( directory.count < 1 || directory.count > HPAK_MAX_ENTRIES )
|
|
{
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
directory.entries = Z_Malloc( sizeof( hpak_lump_t ) * directory.count );
|
|
FS_Read( f, directory.entries, sizeof( hpak_lump_t ) * directory.count );
|
|
bFound = HPAK_FindResource( &directory, hash, pResource );
|
|
Mem_Free( directory.entries );
|
|
FS_Close( f );
|
|
|
|
return bFound;
|
|
}
|
|
|
|
static qboolean HPAK_ResourceForIndex( const char *filename, int index, resource_t *pResource )
|
|
{
|
|
hpak_header_t header;
|
|
hpak_info_t directory;
|
|
string pakname;
|
|
file_t *f;
|
|
|
|
if( !COM_CheckString( filename ) )
|
|
return false;
|
|
|
|
Q_strncpy( pakname, filename, sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
|
|
f = FS_Open( pakname, "rb", false );
|
|
if( !f )
|
|
{
|
|
Con_DPrintf( S_ERROR "couldn't open %s.\n", pakname );
|
|
return false;
|
|
}
|
|
|
|
FS_Read( f, &header, sizeof( header ));
|
|
if( header.ident != IDHPAKHEADER )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s is not an HPAK file\n", pakname );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
if( header.version != IDHPAK_VERSION )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has invalid version (%i should be %i).\n", pakname, header.version, IDHPAK_VERSION );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
FS_Seek( f, header.infotableofs, SEEK_SET );
|
|
FS_Read( f, &directory.count, sizeof( directory.count ));
|
|
|
|
if( directory.count < 1 || directory.count > HPAK_MAX_ENTRIES )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has too many lumps %u.\n", pakname, directory.count );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
if( index < 1 || index > directory.count )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s, lump with index %i doesn't exist.\n", pakname, index );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
directory.entries = Z_Malloc( sizeof( hpak_lump_t ) * directory.count );
|
|
FS_Read( f, directory.entries, sizeof( hpak_lump_t ) * directory.count );
|
|
*pResource = directory.entries[index-1].resource;
|
|
Z_Free( directory.entries );
|
|
FS_Close( f );
|
|
|
|
return true;
|
|
}
|
|
|
|
qboolean HPAK_GetDataPointer( const char *filename, resource_t *pResource, byte **buffer, int *bufsize )
|
|
{
|
|
byte *tmpbuf;
|
|
string pakname;
|
|
hpak_header_t header;
|
|
hpak_info_t directory;
|
|
hpak_lump_t *entry;
|
|
hash_pack_queue_t *p;
|
|
file_t *f;
|
|
int i;
|
|
|
|
if( !COM_CheckString( filename ))
|
|
return false;
|
|
|
|
if( buffer ) *buffer = NULL;
|
|
if( bufsize ) *bufsize = 0;
|
|
|
|
for( p = gp_hpak_queue; p != NULL; p = p->next )
|
|
{
|
|
if( !Q_stricmp(p->name, filename ) && !memcmp( p->resource.rgucMD5_hash, pResource->rgucMD5_hash, 16 ))
|
|
{
|
|
if( buffer )
|
|
{
|
|
tmpbuf = Z_Malloc( p->size );
|
|
memcpy( tmpbuf, p->data, p->size );
|
|
*buffer = tmpbuf;
|
|
}
|
|
|
|
if( bufsize )
|
|
*bufsize = p->size;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Q_strncpy( pakname, filename, sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
|
|
f = FS_Open( pakname, "rb", false );
|
|
if( !f ) return false;
|
|
|
|
FS_Read( f, &header, sizeof( header ));
|
|
|
|
if( header.ident != IDHPAKHEADER )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s it's not a HPK file.\n", pakname );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
if( header.version != IDHPAK_VERSION )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has invalid version (%i should be %i).\n", pakname, header.version, IDHPAK_VERSION );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
FS_Seek( f, header.infotableofs, SEEK_SET );
|
|
FS_Read( f, &directory.count, sizeof( directory.count ));
|
|
|
|
if( directory.count < 1 || directory.count > HPAK_MAX_ENTRIES )
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK_GetDataPointer: %s has too many lumps %u.\n", filename, directory.count );
|
|
FS_Close( f );
|
|
return false;
|
|
}
|
|
|
|
directory.entries = Z_Malloc( sizeof( hpak_lump_t ) * directory.count );
|
|
FS_Read( f, directory.entries, sizeof( hpak_lump_t ) * directory.count );
|
|
|
|
for( i = 0; i < directory.count; i++ )
|
|
{
|
|
entry = &directory.entries[i];
|
|
|
|
if( !memcmp( entry->resource.rgucMD5_hash, pResource->rgucMD5_hash, 16 ))
|
|
{
|
|
FS_Seek( f, entry->filepos, SEEK_SET );
|
|
|
|
if( buffer && entry->disksize > 0 )
|
|
{
|
|
tmpbuf = Z_Malloc( entry->disksize );
|
|
FS_Read( f, tmpbuf, entry->disksize );
|
|
*buffer = tmpbuf;
|
|
}
|
|
|
|
if( bufsize )
|
|
*bufsize = entry->disksize;
|
|
|
|
Mem_Free( directory.entries );
|
|
FS_Close( f );
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Mem_Free( directory.entries );
|
|
FS_Close( f );
|
|
|
|
return false;
|
|
}
|
|
|
|
void HPAK_RemoveLump( const char *name, resource_t *pResource )
|
|
{
|
|
string read_path;
|
|
string save_path;
|
|
file_t *file_src;
|
|
file_t *file_dst;
|
|
hpak_info_t hpak_read;
|
|
hpak_info_t hpak_save;
|
|
int i, j;
|
|
|
|
if( !COM_CheckString( name ) || !pResource )
|
|
return;
|
|
|
|
HPAK_FlushHostQueue();
|
|
|
|
Q_strncpy( read_path, name, sizeof( read_path ));
|
|
COM_ReplaceExtension( read_path, ".hpk" );
|
|
|
|
file_src = FS_Open( read_path, "rb", false );
|
|
if( !file_src )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s couldn't open.\n", read_path );
|
|
return;
|
|
}
|
|
|
|
Q_strncpy( save_path, read_path, sizeof( save_path ));
|
|
COM_ReplaceExtension( save_path, ".hp2" );
|
|
file_dst = FS_Open( save_path, "wb", false );
|
|
|
|
if( !file_dst )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s couldn't open.\n", save_path );
|
|
FS_Close( file_src );
|
|
return;
|
|
}
|
|
|
|
FS_Seek( file_src, 0, SEEK_SET );
|
|
FS_Seek( file_dst, 0, SEEK_SET );
|
|
|
|
// header copy
|
|
FS_Read( file_src, &hash_pack_header, sizeof( hpak_header_t ));
|
|
FS_Write( file_dst, &hash_pack_header, sizeof( hpak_header_t ));
|
|
|
|
if( hash_pack_header.ident != IDHPAKHEADER || hash_pack_header.version != IDHPAK_VERSION )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has invalid header.\n", read_path );
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
FS_Delete( save_path ); // delete temp file
|
|
return;
|
|
}
|
|
|
|
FS_Seek( file_src, hash_pack_header.infotableofs, SEEK_SET );
|
|
FS_Read( file_src, &hpak_read.count, sizeof( hpak_read.count ));
|
|
|
|
if( hpak_read.count < 1 || hpak_read.count > HPAK_MAX_ENTRIES )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has invalid number of lumps.\n", read_path );
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
FS_Delete( save_path ); // delete temp file
|
|
return;
|
|
}
|
|
|
|
if( hpak_read.count == 1 )
|
|
{
|
|
Con_DPrintf( S_WARN "%s only has one element, so HPAK will be removed\n", read_path );
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
FS_Delete( read_path );
|
|
FS_Delete( save_path );
|
|
return;
|
|
}
|
|
|
|
hpak_save.count = hpak_read.count - 1;
|
|
hpak_read.entries = Z_Malloc( sizeof( hpak_lump_t ) * hpak_read.count );
|
|
hpak_save.entries = Z_Malloc( sizeof( hpak_lump_t ) * hpak_save.count );
|
|
|
|
FS_Read( file_src, hpak_read.entries, sizeof( hpak_lump_t ) * hpak_read.count );
|
|
|
|
if( !HPAK_FindResource( &hpak_read, pResource->rgucMD5_hash, NULL ))
|
|
{
|
|
Con_DPrintf( S_ERROR "HPAK %s doesn't contain specified lump: %s\n", read_path, pResource->szFileName );
|
|
Mem_Free( hpak_read.entries );
|
|
Mem_Free( hpak_save.entries );
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
FS_Delete( save_path );
|
|
return;
|
|
}
|
|
|
|
Con_Printf( "Removing %s from HPAK %s.\n", pResource->szFileName, read_path );
|
|
|
|
// If there's a collision, we've just corrupted this hpak.
|
|
for( i = 0, j = 0; i < hpak_read.count; i++ )
|
|
{
|
|
if( !memcmp( hpak_read.entries[i].resource.rgucMD5_hash, pResource->rgucMD5_hash, 16 ))
|
|
continue;
|
|
|
|
hpak_save.entries[j] = hpak_read.entries[i];
|
|
hpak_save.entries[j].filepos = FS_Tell( file_dst );
|
|
FS_Seek( file_src, hpak_read.entries[j].filepos, SEEK_SET );
|
|
FS_FileCopy( file_dst, file_src, hpak_save.entries[j].disksize );
|
|
j++;
|
|
}
|
|
|
|
hash_pack_header.infotableofs = FS_Tell( file_dst );
|
|
FS_Write( file_dst, &hpak_save.count, sizeof( hpak_save.count ));
|
|
|
|
for( i = 0; i < hpak_save.count; i++ )
|
|
FS_Write( file_dst, &hpak_save.entries[i], sizeof( hpak_lump_t ));
|
|
|
|
FS_Seek( file_dst, 0, SEEK_SET );
|
|
FS_Write( file_dst, &hash_pack_header, sizeof( hpak_header_t ));
|
|
|
|
Mem_Free( hpak_read.entries );
|
|
Mem_Free( hpak_save.entries );
|
|
FS_Close( file_src );
|
|
FS_Close( file_dst );
|
|
|
|
FS_Delete( read_path );
|
|
FS_Rename( save_path, read_path );
|
|
}
|
|
|
|
void HPAK_List_f( void )
|
|
{
|
|
int nCurrent;
|
|
hpak_header_t header;
|
|
hpak_info_t directory;
|
|
hpak_lump_t *entry;
|
|
string lumpname;
|
|
string pakname;
|
|
const char *type;
|
|
const char *size;
|
|
file_t *f;
|
|
|
|
if( Cmd_Argc() != 2 )
|
|
{
|
|
Con_Printf( S_USAGE "hpklist <hpk>\n" );
|
|
return;
|
|
}
|
|
|
|
HPAK_FlushHostQueue();
|
|
|
|
Q_strncpy( pakname, Cmd_Argv( 1 ), sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
Con_Printf( "Contents for %s.\n", pakname );
|
|
|
|
f = FS_Open( pakname, "rb", false );
|
|
if( !f )
|
|
{
|
|
Con_DPrintf( S_ERROR "couldn't open %s.\n", pakname );
|
|
return;
|
|
}
|
|
|
|
FS_Read( f, &header, sizeof( hpak_header_t ));
|
|
|
|
if( header.ident != IDHPAKHEADER )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s is not an HPAK file\n", pakname );
|
|
FS_Close( f );
|
|
return;
|
|
}
|
|
|
|
if( header.version != IDHPAK_VERSION )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has invalid version (%i should be %i).\n", pakname, header.version, IDHPAK_VERSION );
|
|
FS_Close( f );
|
|
return;
|
|
}
|
|
|
|
FS_Seek( f, header.infotableofs, SEEK_SET );
|
|
FS_Read( f, &directory.count, sizeof( directory.count ));
|
|
|
|
if( directory.count < 1 || directory.count > HPAK_MAX_ENTRIES )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has too many lumps %u.\n", pakname, directory.count );
|
|
FS_Close( f );
|
|
return;
|
|
}
|
|
|
|
Con_Printf( "# of Entries: %i\n", directory.count );
|
|
Con_Printf( "# Type Size FileName : MD5 Hash\n" );
|
|
|
|
directory.entries = Z_Malloc( directory.count * sizeof( hpak_lump_t ));
|
|
FS_Read( f, directory.entries, directory.count * sizeof( hpak_lump_t ));
|
|
|
|
for( nCurrent = 0; nCurrent < directory.count; nCurrent++ )
|
|
{
|
|
entry = &directory.entries[nCurrent];
|
|
COM_FileBase( entry->resource.szFileName, lumpname );
|
|
type = HPAK_TypeFromIndex( entry->resource.type );
|
|
size = Q_memprint( entry->resource.nDownloadSize );
|
|
|
|
Con_Printf( "%i: %10s %s %s\n : %s\n", nCurrent + 1, type, size, lumpname, MD5_Print( entry->resource.rgucMD5_hash ));
|
|
}
|
|
|
|
if( directory.entries )
|
|
Mem_Free( directory.entries );
|
|
FS_Close( f );
|
|
}
|
|
|
|
void HPAK_Extract_f( void )
|
|
{
|
|
int nCurrent;
|
|
hpak_header_t header;
|
|
hpak_info_t directory;
|
|
hpak_lump_t *entry;
|
|
string lumpname;
|
|
string pakname;
|
|
string szFileOut;
|
|
int nIndex;
|
|
byte *pData;
|
|
int nDataSize;
|
|
const char *type;
|
|
const char *size;
|
|
file_t *f;
|
|
|
|
if( Cmd_Argc() != 3 )
|
|
{
|
|
Con_Printf( S_USAGE "hpkextract hpkname [all | single index]\n" );
|
|
return;
|
|
}
|
|
|
|
if( !Q_stricmp( Cmd_Argv( 2 ), "all" ))
|
|
{
|
|
nIndex = -1;
|
|
}
|
|
else
|
|
{
|
|
nIndex = Q_atoi( Cmd_Argv( 2 ) );
|
|
}
|
|
|
|
HPAK_FlushHostQueue();
|
|
|
|
Q_strncpy( pakname, Cmd_Argv( 1 ), sizeof( pakname ));
|
|
COM_ReplaceExtension( pakname, ".hpk" );
|
|
Con_Printf( "Contents for %s.\n", pakname );
|
|
|
|
f = FS_Open( pakname, "rb", false );
|
|
if( !f )
|
|
{
|
|
Con_DPrintf( S_ERROR "couldn't open %s.\n", pakname );
|
|
return;
|
|
}
|
|
|
|
FS_Read( f, &header, sizeof( hpak_header_t ));
|
|
|
|
if( header.ident != IDHPAKHEADER )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s is not an HPAK file\n", pakname );
|
|
FS_Close( f );
|
|
return;
|
|
}
|
|
|
|
if( header.version != IDHPAK_VERSION )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has invalid version (%i should be %i).\n", pakname, header.version, IDHPAK_VERSION );
|
|
FS_Close( f );
|
|
return;
|
|
}
|
|
|
|
FS_Seek( f, header.infotableofs, SEEK_SET );
|
|
FS_Read( f, &directory.count, sizeof( directory.count ));
|
|
|
|
if( directory.count < 1 || directory.count > HPAK_MAX_ENTRIES )
|
|
{
|
|
Con_DPrintf( S_ERROR "%s has too many lumps %u.\n", pakname, directory.count );
|
|
FS_Close( f );
|
|
return;
|
|
}
|
|
|
|
if( nIndex == -1 ) Con_Printf( "Extracting all lumps from %s.\n", pakname );
|
|
else Con_Printf( "Extracting lump %i from %s\n", nIndex, pakname );
|
|
|
|
directory.entries = Z_Malloc( directory.count * sizeof( hpak_lump_t ));
|
|
FS_Read( f, directory.entries, directory.count * sizeof( hpak_lump_t ));
|
|
|
|
for( nCurrent = 0; nCurrent < directory.count; nCurrent++ )
|
|
{
|
|
entry = &directory.entries[nCurrent];
|
|
|
|
if( nIndex != -1 && nIndex != nCurrent )
|
|
continue;
|
|
|
|
COM_FileBase( entry->resource.szFileName, lumpname );
|
|
type = HPAK_TypeFromIndex( entry->resource.type );
|
|
size = Q_memprint( entry->resource.nDownloadSize );
|
|
|
|
Con_Printf( "Extracting %i: %10s %s %s\n", nCurrent + 1, type, size, lumpname );
|
|
|
|
if( entry->disksize <= 0 || entry->disksize >= HPAK_MAX_SIZE )
|
|
{
|
|
Con_DPrintf( S_WARN "Unable to extract data, size invalid: %s\n", Q_memprint( entry->disksize ));
|
|
continue;
|
|
}
|
|
|
|
nDataSize = entry->disksize;
|
|
pData = Z_Malloc( nDataSize + 1 );
|
|
FS_Seek( f, entry->filepos, SEEK_SET );
|
|
FS_Read( f, pData, nDataSize );
|
|
|
|
Q_snprintf( szFileOut, sizeof( szFileOut ), "hpklmps\\lmp%04i.bmp", nCurrent );
|
|
FS_WriteFile( szFileOut, pData, nDataSize );
|
|
if( pData ) Mem_Free( pData );
|
|
}
|
|
|
|
if( directory.entries )
|
|
Mem_Free( directory.entries );
|
|
|
|
FS_Close( f );
|
|
}
|
|
|
|
void HPAK_Remove_f( void )
|
|
{
|
|
resource_t resource;
|
|
|
|
HPAK_FlushHostQueue();
|
|
|
|
if( Cmd_Argc() != 3 )
|
|
{
|
|
Con_Printf( S_USAGE "hpkremove <hpk> <index>\n" );
|
|
return;
|
|
}
|
|
|
|
if( HPAK_ResourceForIndex( Cmd_Argv( 1 ), Q_atoi( Cmd_Argv( 2 )), &resource ))
|
|
{
|
|
HPAK_RemoveLump( Cmd_Argv( 1 ), &resource );
|
|
}
|
|
else
|
|
{
|
|
Con_DPrintf( S_ERROR "Could not locate resource %i in %s\n", Q_atoi( Cmd_Argv( 2 )), Cmd_Argv( 1 ));
|
|
}
|
|
}
|
|
|
|
void HPAK_Validate_f( void )
|
|
{
|
|
if( Cmd_Argc() != 2 )
|
|
{
|
|
Con_Printf( S_USAGE "hpkval <filename>\n" );
|
|
return;
|
|
}
|
|
|
|
HPAK_Validate( Cmd_Argv( 1 ), false );
|
|
}
|
|
|
|
void HPAK_Init( void )
|
|
{
|
|
Cmd_AddRestrictedCommand( "hpklist", HPAK_List_f, "list all files in specified HPK-file" );
|
|
Cmd_AddRestrictedCommand( "hpkremove", HPAK_Remove_f, "remove specified file from HPK-file" );
|
|
Cmd_AddRestrictedCommand( "hpkval", HPAK_Validate_f, "validate specified HPK-file" );
|
|
Cmd_AddRestrictedCommand( "hpkextract", HPAK_Extract_f, "extract all lumps from specified HPK-file" );
|
|
hpk_maxsize = Cvar_Get( "hpk_maxsize", "0", FCVAR_ARCHIVE, "set limit by size for all HPK-files ( 0 - unlimited )" );
|
|
|
|
gp_hpak_queue = NULL;
|
|
}
|