2856 lines
71 KiB
C
2856 lines
71 KiB
C
// SONIC ROBO BLAST 2
|
||
//-----------------------------------------------------------------------------
|
||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||
// Copyright (C) 1999-2018 by Sonic Team Junior.
|
||
//
|
||
// This program is free software distributed under the
|
||
// terms of the GNU General Public License, version 2.
|
||
// See the 'LICENSE' file for more details.
|
||
//-----------------------------------------------------------------------------
|
||
/// \file w_wad.c
|
||
/// \brief Handles WAD file header, directory, lump I/O
|
||
|
||
#ifdef HAVE_ZLIB
|
||
#ifndef _LARGEFILE64_SOURCE
|
||
#define _LARGEFILE64_SOURCE
|
||
#endif
|
||
|
||
#ifndef _LFS64_LARGEFILE
|
||
#define _LFS64_LARGEFILE
|
||
#endif
|
||
|
||
#ifndef _FILE_OFFSET_BITS
|
||
#define _FILE_OFFSET_BITS 0
|
||
#endif
|
||
|
||
#include "zlib.h"
|
||
#endif
|
||
|
||
#ifdef __GNUC__
|
||
#include <unistd.h>
|
||
#endif
|
||
|
||
#define ZWAD
|
||
|
||
#ifdef ZWAD
|
||
#include <errno.h>
|
||
#include "lzf.h"
|
||
#endif
|
||
|
||
#include "doomdef.h"
|
||
#include "doomstat.h"
|
||
#include "doomtype.h"
|
||
|
||
#include "w_wad.h"
|
||
#include "z_zone.h"
|
||
#include "fastcmp.h"
|
||
#include "console.h"
|
||
|
||
#include "g_game.h" // G_LoadGameData
|
||
#include "d_main.h"
|
||
#include "filesrch.h"
|
||
|
||
#include "i_time.h"
|
||
#include "i_video.h" // rendermode
|
||
#include "d_netfil.h"
|
||
#include "dehacked.h"
|
||
#include "d_clisrv.h"
|
||
#include "r_defs.h"
|
||
#include "r_patch.h"
|
||
#include "i_system.h"
|
||
#include "md5.h"
|
||
#include "lua_script.h"
|
||
#include "st_stuff.h"
|
||
#include "m_misc.h" // M_MapNumber
|
||
#include "p_setup.h" // P_PartialAddFile mayb
|
||
#include "k_hud.h"
|
||
|
||
#ifdef HWRENDER
|
||
#include "r_data.h"
|
||
#include "hardware/hw_main.h"
|
||
#include "hardware/hw_glob.h"
|
||
#endif
|
||
|
||
#ifdef ROTSPRITE
|
||
#include "r_patchrotation.h" // RotatedPatch_Create
|
||
#endif
|
||
|
||
#ifndef O_BINARY
|
||
#define O_BINARY 0
|
||
#endif
|
||
|
||
typedef struct
|
||
{
|
||
const char *name;
|
||
size_t len;
|
||
} lumpchecklist_t;
|
||
|
||
// Must be a power of two
|
||
#define LUMPNUMCACHESIZE 2048 // should be reasonable ig
|
||
#define LUMPNUMCACHENAME 32
|
||
|
||
#define NAME lumpnum_map
|
||
#define KEY_TY char *
|
||
#define KEY_GET_CONST
|
||
#define VAL_TY lumpnum_t
|
||
#define HASH_FN vt_hash_string
|
||
#define CMPR_FN vt_cmpr_string
|
||
#define KEY_DTOR_FN free
|
||
#include "verstable.h"
|
||
|
||
#define NAME folder_map
|
||
#define KEY_TY char *
|
||
#define KEY_GET_CONST
|
||
#define VAL_TY UINT16
|
||
#define HASH_FN vt_hash_string
|
||
#define CMPR_FN vt_cmpr_string
|
||
#define KEY_DTOR_FN free
|
||
#include "verstable.h"
|
||
|
||
static lumpnum_map lumpnumcache;
|
||
|
||
typedef struct FolderCache {
|
||
folder_map map;
|
||
} FolderCache;
|
||
|
||
static const char pat_central[] = {0x50, 0x4b, 0x01, 0x02, 0x00};
|
||
static const char pat_end[] = {0x50, 0x4b, 0x05, 0x06, 0x00};
|
||
|
||
//===========================================================================
|
||
// GLOBALS
|
||
//===========================================================================
|
||
UINT16 numwadfiles = 0; // number of active wadfiles
|
||
wadfile_t *wadfiles[MAX_WADFILES] = {}; // 0 to numwadfiles-1 are valid
|
||
|
||
// use strnlen as some lump names may not be null terminated
|
||
#define CHECKMAPMARKER(name) (memcmp(name, "MAP", 3) == 0 && strnlen(name, 8) == 5)
|
||
|
||
// W_Shutdown
|
||
// Closes all of the WAD files before quitting
|
||
// If not done on a Mac then open wad files
|
||
// can prevent removable media they are on from
|
||
// being ejected
|
||
DESTRUCTOR static void W_Shutdown(void)
|
||
{
|
||
lumpnum_map_cleanup(&lumpnumcache);
|
||
|
||
while (numwadfiles--)
|
||
{
|
||
wadfile_t *wad = wadfiles[numwadfiles];
|
||
|
||
if (wad->handle)
|
||
fclose(wad->handle);
|
||
|
||
Z_Free(wad->filename);
|
||
|
||
while (wad->numlumps--)
|
||
{
|
||
//Z_Free(wad->lumpinfo[wad->numlumps].longname);
|
||
Z_Free(wad->lumpinfo[wad->numlumps].fullname);
|
||
}
|
||
|
||
folder_map_cleanup(&wad->startfolders->map);
|
||
free(wad->startfolders);
|
||
folder_map_cleanup(&wad->endfolders->map);
|
||
free(wad->endfolders);
|
||
|
||
Z_Free(wad->lumpinfo);
|
||
Z_Free(wad);
|
||
}
|
||
}
|
||
|
||
// the lumpnum cache needs to be initialized before use
|
||
CONSTRUCTOR static void W_Startup(void)
|
||
{
|
||
lumpnum_map_init(&lumpnumcache);
|
||
lumpnum_map_reserve(&lumpnumcache, LUMPNUMCACHESIZE);
|
||
}
|
||
|
||
//===========================================================================
|
||
// LUMP BASED ROUTINES
|
||
//===========================================================================
|
||
|
||
// W_AddFile
|
||
// All files are optional, but at least one file must be
|
||
// found (PWAD, if all required lumps are present).
|
||
// Files with a .wad extension are wadlink files
|
||
// with multiple lumps.
|
||
// Other files are single lumps with the base filename
|
||
// for the lump name.
|
||
|
||
static char filenamebuf[MAX_WADPATH];
|
||
|
||
// This #if is copied from filesrch.c, so not sure if it is 100% suitable for
|
||
// this
|
||
#if defined (_WIN32)
|
||
//#define WIN32_LEAN_AND_MEAN
|
||
#define RPC_NO_WINDOWS_H
|
||
#include <windows.h>
|
||
|
||
// Windows can't open utf-8 path so it must be converted to utf-16
|
||
static FILE* fopen_utf8(const char* filename, const char* mode)
|
||
{
|
||
static const int MY_PATH_MAX = 2048;
|
||
WCHAR nameW[MY_PATH_MAX];
|
||
memset(nameW, 0, sizeof(WCHAR)*MY_PATH_MAX);
|
||
WCHAR modeW[16];
|
||
memset(modeW, 0, sizeof(WCHAR)*16);
|
||
// the following function converts the UTF-8 filename to UTF-16 (WCHAR) nameW
|
||
int len = MultiByteToWideChar(CP_UTF8, 0, filename, -1, nameW, MY_PATH_MAX);
|
||
if(len > 0 && MultiByteToWideChar(CP_UTF8, 0, mode, -1, modeW, 16) > 0)
|
||
{
|
||
// using _wfopen_s() shuts up MSVC's complaints
|
||
// about _wfopen() being unsafe..
|
||
FILE* ret = NULL;
|
||
if(_wfopen_s(&ret, nameW, modeW) == 0)
|
||
return ret;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
#else
|
||
|
||
#define fopen_utf8 fopen
|
||
|
||
#endif
|
||
|
||
// W_OpenWadFile
|
||
// Helper function for opening the WAD file.
|
||
// Returns the FILE * handle for the file, or NULL if not found or could not be opened
|
||
// If "useerrors" is true then print errors in the console, else just don't bother
|
||
// "filename" may be modified to have the correct path the actual file is located in, if necessary
|
||
FILE *W_OpenWadFile(const char **filename, boolean useerrors)
|
||
{
|
||
FILE *handle;
|
||
|
||
// Officially, strncpy should not have overlapping buffers, since W_VerifyNMUSlumps is called after this, and it
|
||
// changes filename to point at filenamebuf, it would technically be doing that. I doubt any issue will occur since
|
||
// they point to the same location, but it's better to be safe and this is a simple change.
|
||
if (filenamebuf != *filename)
|
||
{
|
||
strncpy(filenamebuf, *filename, MAX_WADPATH);
|
||
filenamebuf[MAX_WADPATH - 1] = '\0';
|
||
*filename = filenamebuf;
|
||
}
|
||
|
||
// open wad file
|
||
if ((handle = fopen_utf8(*filename, "rb")) == NULL)
|
||
{
|
||
// If we failed to load the file with the path as specified by
|
||
// the user, strip the directories and search for the file.
|
||
nameonly(filenamebuf);
|
||
|
||
// If findfile finds the file, the full path will be returned
|
||
// in filenamebuf == *filename.
|
||
if (findfile(filenamebuf, NULL, true) == FS_FOUND)
|
||
{
|
||
if ((handle = fopen_utf8(*filename, "rb")) == NULL)
|
||
{
|
||
if (useerrors)
|
||
CONS_Alert(CONS_ERROR, M_GetText("Can't open %s\n"), *filename);
|
||
return NULL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (useerrors)
|
||
CONS_Alert(CONS_ERROR, M_GetText("File %s not found.\n"), *filename);
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
return handle;
|
||
}
|
||
|
||
// Look for all DEHACKED and Lua scripts inside a PK3 archive.
|
||
static inline void W_LoadDehackedLumpsPK3(UINT16 wadnum)
|
||
{
|
||
UINT16 posStart, posEnd;
|
||
|
||
posStart = W_CheckNumForFolderStartPK3("Lua/", wadnum, 0);
|
||
if (posStart != INT16_MAX)
|
||
{
|
||
posEnd = W_CheckNumForFolderEndPK3("Lua/", wadnum, posStart);
|
||
for (; posStart < posEnd; posStart++)
|
||
LUA_LoadLump(wadnum, posStart);
|
||
}
|
||
|
||
posStart = W_CheckNumForFolderStartPK3("SOC/", wadnum, 0);
|
||
if (posStart != INT16_MAX)
|
||
{
|
||
posEnd = W_CheckNumForFolderEndPK3("SOC/", wadnum, posStart);
|
||
size_t len = strlen(wadfiles[wadnum]->filename);
|
||
|
||
for (; posStart < posEnd; posStart++)
|
||
{
|
||
lumpinfo_t *lump_p = &wadfiles[wadnum]->lumpinfo[posStart];
|
||
|
||
size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
|
||
char *name = (char *)(malloc(length + 1));
|
||
|
||
if (!name)
|
||
I_Error("W_LoadDehackedLumpsPK3: Out of memory!\n");
|
||
|
||
sprintf(name, "%s|%s", wadfiles[wadnum]->filename, lump_p->fullname);
|
||
name[length] = '\0';
|
||
CONS_Printf("Loading SOC from %s\n", name);
|
||
DEH_LoadDehackedLumpPwad(wadnum, posStart);
|
||
free(name);
|
||
}
|
||
}
|
||
}
|
||
|
||
// search for all DEHACKED lump in all wads and load it
|
||
static inline void W_LoadDehackedLumps(UINT16 wadnum)
|
||
{
|
||
UINT16 lump;
|
||
lumpinfo_t *lump_p;
|
||
|
||
// Find Lua scripts before SOCs to allow new A_Actions in SOC editing.
|
||
lump_p = wadfiles[wadnum]->lumpinfo;
|
||
|
||
for (lump = 0; lump < wadfiles[wadnum]->numlumps; lump++, lump_p++)
|
||
if (memcmp(lump_p->name, "LUA_", 4) == 0)
|
||
LUA_LoadLump(wadnum, lump);
|
||
|
||
lump_p = wadfiles[wadnum]->lumpinfo;
|
||
|
||
const size_t len = strlen(wadfiles[wadnum]->filename);
|
||
|
||
for (lump = 0; lump < wadfiles[wadnum]->numlumps; lump++, lump_p++)
|
||
{
|
||
if (memcmp(lump_p->name, "SOC_", 4) == 0) // Check for generic SOC lump
|
||
{ // shameless copy+paste of code from LUA_LoadLump
|
||
size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
|
||
char *name = (char *)(malloc(length + 1));
|
||
|
||
if (!name)
|
||
I_Error("W_LoadDehackedLumps: Out of memory!\n");
|
||
|
||
sprintf(name, "%s|%s", wadfiles[wadnum]->filename, lump_p->fullname);
|
||
name[length] = '\0';
|
||
|
||
CONS_Printf(M_GetText("Loading SOC from %s\n"), name);
|
||
DEH_LoadDehackedLumpPwad(wadnum, lump);
|
||
free(name);
|
||
}
|
||
else if (memcmp(lump_p->name, "MAINCFG", 8) == 0) // Check for MAINCFG
|
||
{
|
||
CONS_Printf(M_GetText("Loading main config from %s\n"), wadfiles[wadnum]->filename);
|
||
DEH_LoadDehackedLumpPwad(wadnum, lump);
|
||
}
|
||
else if (memcmp(lump_p->name, "OBJCTCFG", 8) == 0) // Check for OBJCTCFG
|
||
{
|
||
CONS_Printf(M_GetText("Loading object config from %s\n"), wadfiles[wadnum]->filename);
|
||
DEH_LoadDehackedLumpPwad(wadnum, lump);
|
||
}
|
||
}
|
||
}
|
||
|
||
/** Compute MD5 message digest for bytes read from STREAM of this filname.
|
||
*
|
||
* The resulting message digest number will be written into the 16 bytes
|
||
* beginning at RESBLOCK.
|
||
*
|
||
* \param filename path of file
|
||
* \param resblock resulting MD5 checksum
|
||
* \return 0 if MD5 checksum was made, and is at resblock, 1 if error was found
|
||
*/
|
||
static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
|
||
{
|
||
#ifdef NOMD5
|
||
(void)filename;
|
||
memset(resblock, 0x00, 16);
|
||
#else
|
||
FILE *fhandle;
|
||
|
||
if ((fhandle = fopen(filename, "rb")) != NULL)
|
||
{
|
||
precise_t t = I_GetPreciseTime();
|
||
|
||
CONS_Debug(DBG_SETUP, "Making MD5 for %s\n", filename);
|
||
|
||
if (md5_stream(fhandle, resblock) == 1)
|
||
{
|
||
fclose(fhandle);
|
||
return 1;
|
||
}
|
||
|
||
CONS_Debug(DBG_SETUP, "MD5 calc for %s took %f seconds\n",
|
||
filename, (float)(I_GetPreciseTime() - t)/I_GetPrecisePrecision());
|
||
|
||
fclose(fhandle);
|
||
return 0;
|
||
}
|
||
#endif
|
||
return 1;
|
||
}
|
||
|
||
// Invalidates the cache of lump numbers. Call this whenever a wad is added.
|
||
FUNCINLINE static ATTRINLINE void W_InvalidateLumpnumCache(void)
|
||
{
|
||
lumpnum_map_clear(&lumpnumcache);
|
||
}
|
||
|
||
FUNCINLINE static ATTRINLINE UINT32 W_HashLumpName(const char *name)
|
||
{
|
||
return FNV1a_HashLowercaseString(name);
|
||
}
|
||
|
||
/** Detect a file type.
|
||
* \todo Actually detect the wad/pkzip headers and whatnot, instead of just checking the extensions.
|
||
*/
|
||
static restype_t ResourceFileDetect(const char* filename)
|
||
{
|
||
size_t len = strlen(filename) - 4;
|
||
|
||
if (fasticmp(&filename[len], ".pk3"))
|
||
return RET_PK3;
|
||
if (fasticmp(&filename[len], ".soc"))
|
||
return RET_SOC;
|
||
if (fasticmp(&filename[len], ".lua"))
|
||
return RET_LUA;
|
||
|
||
return RET_WAD;
|
||
}
|
||
|
||
/** Create a 1-lump lumpinfo_t for standalone files.
|
||
*/
|
||
static lumpinfo_t* ResGetLumpsStandalone(FILE* handle, UINT16* numlumps, const char* lumpname)
|
||
{
|
||
lumpinfo_t* lumpinfo = (lumpinfo_t *)(Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL));
|
||
lumpinfo->position = 0;
|
||
fseek(handle, 0, SEEK_END);
|
||
lumpinfo->size = (size_t)(ftell(handle));
|
||
fseek(handle, 0, SEEK_SET);
|
||
strlcpy(lumpinfo->name, lumpname, sizeof(lumpinfo->name));
|
||
lumpinfo->namelength = strlen(lumpinfo->name);
|
||
lumpinfo->hash.name = W_HashLumpName(lumpname);
|
||
|
||
// Allocate the lump's long name.
|
||
/*lumpinfo->longname = (char *)(Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL));
|
||
strcpy(lumpinfo->longname, lumpname);
|
||
lumpinfo->longname[lumpinfo->namelength] = '\0';
|
||
lumpinfo->longnamelength = lumpinfo->namelength;
|
||
lumpinfo->hash.longname = lumpinfo->hash.name;*/
|
||
|
||
// Allocate the lump's full name.
|
||
lumpinfo->fullname = (char *)(Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL));
|
||
strcpy(lumpinfo->fullname, lumpname);
|
||
lumpinfo->fullname[lumpinfo->namelength] = '\0';
|
||
lumpinfo->fullnamelength = lumpinfo->namelength;
|
||
//lumpinfo->hash.fullname = lumpinfo->hash.name;
|
||
|
||
*numlumps = 1;
|
||
return lumpinfo;
|
||
}
|
||
|
||
/** Create a lumpinfo_t array for a WAD file.
|
||
*/
|
||
static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filename)
|
||
{
|
||
UINT16 numlumps = *nlmp;
|
||
lumpinfo_t* lumpinfo;
|
||
size_t i;
|
||
INT32 compressed = 0;
|
||
|
||
wadinfo_t header;
|
||
lumpinfo_t *lump_p;
|
||
filelump_t *fileinfo = NULL;
|
||
CLEANUP(pfree) void *fileinfov = NULL;
|
||
|
||
// read the header
|
||
if (fread(&header, 1, sizeof header, handle) < sizeof header)
|
||
{
|
||
CONS_Alert(CONS_ERROR, M_GetText("Can't read wad header because %s\n"), M_FileError(handle));
|
||
return NULL;
|
||
}
|
||
|
||
if (memcmp(header.identification, "ZWAD", 4) == 0)
|
||
{
|
||
compressed = 1;
|
||
}
|
||
else if (memcmp(header.identification, "IWAD", 4) != 0
|
||
&& memcmp(header.identification, "PWAD", 4) != 0
|
||
&& memcmp(header.identification, "SDLL", 4) != 0)
|
||
{
|
||
CONS_Alert(CONS_ERROR, M_GetText("Invalid WAD header\n"));
|
||
return NULL;
|
||
}
|
||
|
||
header.numlumps = LONG(header.numlumps);
|
||
header.infotableofs = LONG(header.infotableofs);
|
||
|
||
// read wad file directory
|
||
i = header.numlumps * sizeof(*fileinfo);
|
||
fileinfov = fileinfo = (filelump_t *)(malloc(i));
|
||
|
||
if (fseek(handle, header.infotableofs, SEEK_SET) == -1
|
||
|| fread(fileinfo, 1, i, handle) < i)
|
||
{
|
||
CONS_Alert(CONS_ERROR, M_GetText("Corrupt wadfile directory (%s)\n"), M_FileError(handle));
|
||
return NULL;
|
||
}
|
||
|
||
numlumps = header.numlumps;
|
||
|
||
// fill in lumpinfo for this wad
|
||
lump_p = lumpinfo = (lumpinfo_t *)(Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL));
|
||
|
||
for (i = 0; i < numlumps; i++, lump_p++, fileinfo++)
|
||
{
|
||
lump_p->position = LONG(fileinfo->filepos);
|
||
lump_p->size = lump_p->disksize = LONG(fileinfo->size);
|
||
|
||
if (compressed) // wad is compressed, lump might be
|
||
{
|
||
UINT32 realsize = 0;
|
||
|
||
if (fseek(handle, lump_p->position, SEEK_SET) == -1
|
||
|| fread(&realsize, 1, sizeof realsize, handle) < sizeof(realsize))
|
||
{
|
||
I_Error("corrupt compressed file: %s; maybe %s", filename, M_FileError(handle)); /// \todo Avoid the bailout?
|
||
}
|
||
|
||
realsize = LONG(realsize);
|
||
|
||
if (realsize != 0)
|
||
{
|
||
lump_p->size = realsize;
|
||
lump_p->compression = CM_LZF;
|
||
}
|
||
else
|
||
{
|
||
lump_p->size -= 4;
|
||
lump_p->compression = CM_NOCOMPRESSION;
|
||
}
|
||
|
||
lump_p->position += 4;
|
||
lump_p->disksize -= 4;
|
||
}
|
||
else
|
||
{
|
||
lump_p->compression = CM_NOCOMPRESSION;
|
||
}
|
||
|
||
memset(lump_p->name, 0x00, 9);
|
||
strncpy(lump_p->name, fileinfo->name, 8);
|
||
lump_p->namelength = strlen(lump_p->name);
|
||
lump_p->hash.name = W_HashLumpName(lump_p->name);
|
||
|
||
// Allocate the lump's long name.
|
||
/*lump_p->longname = (char *)(Z_Malloc(9 * sizeof(char), PU_STATIC, NULL));
|
||
strncpy(lump_p->longname, fileinfo->name, 8);
|
||
lump_p->longname[8] = '\0';
|
||
lump_p->longnamelength = lump_p->namelength;
|
||
lump_p->hash.longname = lump_p->hash.name;*/
|
||
|
||
// Allocate the lump's full name.
|
||
lump_p->fullname = (char *)(Z_Malloc(9 * sizeof(char), PU_STATIC, NULL));
|
||
strncpy(lump_p->fullname, fileinfo->name, 8);
|
||
lump_p->fullname[8] = '\0';
|
||
lump_p->fullnamelength = lump_p->namelength;
|
||
//lump_p->hash.fullname = lump_p->hash.name;
|
||
}
|
||
|
||
*nlmp = numlumps;
|
||
return lumpinfo;
|
||
}
|
||
|
||
/** Optimized pattern search in a file.
|
||
*/
|
||
static boolean ResFindSignature(FILE* handle, const char endPat[], UINT32 startpos)
|
||
{
|
||
//the Wii U has rather slow filesystem access, and fgetc is *unbearable*
|
||
//so I reimplemented this function to buffer 128k chunks
|
||
const char *s;
|
||
int c;
|
||
|
||
fseek(handle, 0, SEEK_END);
|
||
size_t len = (size_t)(ftell(handle));
|
||
|
||
fseek(handle, startpos, SEEK_SET);
|
||
size_t remaining = (size_t)(len - startpos);
|
||
size_t chunkpos = (size_t)(startpos);
|
||
|
||
s = endPat;
|
||
|
||
//128k buffers
|
||
size_t buffer_size = min(128 * 1024 * sizeof(char), remaining);
|
||
CLEANUP(pfree) char* buffer = (char *)(malloc(buffer_size));
|
||
|
||
size_t bytes_read = 0;
|
||
while ((bytes_read = fread(buffer, 1, buffer_size, handle)) > 0)
|
||
{
|
||
for (size_t i = 0; i < bytes_read; i++)
|
||
{
|
||
c = (int)(buffer[i]);
|
||
|
||
if (*s != c && s > endPat) // No match?
|
||
s = endPat; // We "reset" the counter by sending the s pointer back to the start of the array.
|
||
|
||
if (*s == c)
|
||
{
|
||
s++;
|
||
|
||
if (*s == 0x00) // The array pointer has reached the key char which marks the end. It means we have matched the signature.
|
||
{
|
||
//the original function would leave the FILE* seeked to the end of the match
|
||
size_t foundpos = (size_t)(chunkpos + i + 1);
|
||
fseek(handle, foundpos, SEEK_SET);
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
chunkpos += bytes_read;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
typedef struct zend_s
|
||
{
|
||
char signature[4];
|
||
UINT16 diskpos;
|
||
UINT16 cdirdisk;
|
||
UINT16 diskentries;
|
||
UINT16 entries;
|
||
UINT32 cdirsize;
|
||
UINT32 cdiroffset;
|
||
UINT16 commentlen;
|
||
} ATTRPACK zend_t;
|
||
|
||
typedef struct zentry_s
|
||
{
|
||
char signature[4];
|
||
UINT16 version;
|
||
UINT16 versionneeded;
|
||
UINT16 flags;
|
||
UINT16 compression;
|
||
UINT16 modtime;
|
||
UINT16 moddate;
|
||
UINT32 CRC32;
|
||
UINT32 compsize;
|
||
UINT32 size;
|
||
UINT16 namelen;
|
||
UINT16 xtralen;
|
||
UINT16 commlen;
|
||
UINT16 diskstart;
|
||
UINT16 attrint;
|
||
UINT32 attrext;
|
||
UINT32 offset;
|
||
} ATTRPACK zentry_t;
|
||
|
||
typedef struct zlentry_s
|
||
{
|
||
char signature[4];
|
||
UINT16 versionneeded;
|
||
UINT16 flags;
|
||
UINT16 compression;
|
||
UINT16 modtime;
|
||
UINT16 moddate;
|
||
UINT32 CRC32;
|
||
UINT32 compsize;
|
||
UINT32 size;
|
||
UINT16 namelen;
|
||
UINT16 xtralen;
|
||
} ATTRPACK zlentry_t;
|
||
|
||
/** Create a lumpinfo_t array for a PKZip file.
|
||
*/
|
||
static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
|
||
{
|
||
zend_t zend;
|
||
zlentry_t zlentry;
|
||
|
||
UINT16 numlumps = *nlmp;
|
||
lumpinfo_t* lumpinfo = NULL;
|
||
lumpinfo_t *lump_p;
|
||
size_t i;
|
||
|
||
// Look for central directory end signature near end of file.
|
||
// Contains entry number (number of lumps), and central directory start offset.
|
||
fseek(handle, 0, SEEK_END);
|
||
|
||
const long startpos = ftell(handle) - (22 + 65536);
|
||
if (!ResFindSignature(handle, pat_end, max(0l, startpos)))
|
||
{
|
||
CONS_Alert(CONS_ERROR, "Missing central directory\n");
|
||
return NULL;
|
||
}
|
||
|
||
fseek(handle, -4, SEEK_CUR);
|
||
if (fread(&zend, 1, sizeof zend, handle) < sizeof zend)
|
||
{
|
||
CONS_Alert(CONS_ERROR, "Corrupt central directory (%s)\n", M_FileError(handle));
|
||
return NULL;
|
||
}
|
||
|
||
numlumps = SHORT(zend.entries);
|
||
|
||
lump_p = lumpinfo = (lumpinfo_t *)(Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL));
|
||
|
||
fseek(handle, LONG(zend.cdiroffset), SEEK_SET);
|
||
|
||
CLEANUP(Z_Pfree) char *cdir = (char *)(Z_Malloc(LONG(zend.cdirsize), PU_STATIC, &cdir));
|
||
|
||
if (fread(cdir, 1, LONG(zend.cdirsize), handle) < (UINT32)(LONG(zend.cdirsize)))
|
||
{
|
||
CONS_Alert(CONS_ERROR, "Failed to read central directory (%s)\n", M_FileError(handle));
|
||
Z_Free(lumpinfo);
|
||
return NULL;
|
||
}
|
||
|
||
size_t offset = 0;
|
||
|
||
for (i = 0; i < numlumps; i++, lump_p++)
|
||
{
|
||
zentry_t *zentry = (zentry_t *)(cdir + offset);
|
||
char* fullname;
|
||
char* trimname;
|
||
char* dotpos;
|
||
|
||
if (memcmp(zentry->signature, pat_central, 4))
|
||
{
|
||
CONS_Alert(CONS_ERROR, "Central directory is corrupt\n");
|
||
Z_Free(lumpinfo);
|
||
return NULL;
|
||
}
|
||
|
||
lump_p->position = LONG(zentry->offset); // NOT ACCURATE YET: we still need to read the local entry to find our true position
|
||
lump_p->disksize = LONG(zentry->compsize);
|
||
lump_p->size = LONG(zentry->size);
|
||
|
||
fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
|
||
strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
|
||
fullname[zentry->namelen] = 0;
|
||
|
||
// Strip away file address and extension for the 8char name.
|
||
if ((trimname = strrchr(fullname, '/')) != NULL)
|
||
trimname++;
|
||
else
|
||
trimname = fullname; // Care taken for root files.
|
||
|
||
if ((dotpos = strrchr(trimname, '.')) == NULL)
|
||
dotpos = fullname + strlen(fullname); // Watch for files without extension.
|
||
|
||
memset(lump_p->name, '\0', 9); // Making sure they're initialized to 0. Is it necessary?
|
||
strncpy(lump_p->name, trimname, min(8, dotpos - trimname));
|
||
lump_p->namelength = strlen(lump_p->name);
|
||
lump_p->hash.name = W_HashLumpName(lump_p->name);
|
||
|
||
/*lump_p->longname = (char *)(Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL));
|
||
strlcpy(lump_p->longname, trimname, dotpos - trimname + 1);
|
||
lump_p->longnamelength = strlen(lump_p->longname);
|
||
lump_p->hash.longname = W_HashLumpName(lump_p->longname);*/
|
||
|
||
lump_p->fullname = (char *)(Z_Calloc(SHORT(zentry->namelen) + 1, PU_STATIC, NULL));
|
||
strncpy(lump_p->fullname, fullname, SHORT(zentry->namelen));
|
||
lump_p->fullnamelength = zentry->namelen;
|
||
//lump_p->hash.fullname = W_HashLumpName(lump_p->fullname);
|
||
|
||
switch(SHORT(zentry->compression))
|
||
{
|
||
case 0:
|
||
lump_p->compression = CM_NOCOMPRESSION;
|
||
break;
|
||
#ifdef HAVE_ZLIB
|
||
case 8:
|
||
lump_p->compression = CM_DEFLATE;
|
||
break;
|
||
#endif
|
||
case 14:
|
||
lump_p->compression = CM_LZF;
|
||
break;
|
||
default:
|
||
CONS_Alert(CONS_WARNING, "%s: Unsupported compression method\n", fullname);
|
||
lump_p->compression = CM_UNSUPPORTED;
|
||
break;
|
||
}
|
||
|
||
free(fullname);
|
||
|
||
// skip and ignore comments/extra fields
|
||
offset += sizeof *zentry + SHORT(zentry->namelen) + SHORT(zentry->xtralen) + SHORT(zentry->commlen);
|
||
}
|
||
|
||
// Adjust lump position values properly
|
||
for (i = 0, lump_p = lumpinfo; i < numlumps; i++, lump_p++)
|
||
{
|
||
// skip and ignore comments/extra fields
|
||
if ((fseek(handle, lump_p->position, SEEK_SET) != 0) || (fread(&zlentry, 1, sizeof(zlentry_t), handle) < sizeof(zlentry_t)))
|
||
{
|
||
CONS_Alert(CONS_ERROR, "Local headers for lump %s are corrupt\n", lump_p->fullname);
|
||
Z_Free(lumpinfo);
|
||
return NULL;
|
||
}
|
||
|
||
lump_p->position += sizeof(zlentry_t) + SHORT(zlentry.namelen) + SHORT(zlentry.xtralen);
|
||
}
|
||
|
||
*nlmp = numlumps;
|
||
return lumpinfo;
|
||
}
|
||
|
||
static UINT16 W_InitFileError(const char *filename, boolean exitworthy)
|
||
{
|
||
if (exitworthy)
|
||
{
|
||
CONS_Error(va("%s was not found or not valid.\nCheck the log for more details.\n", filename));
|
||
}
|
||
else
|
||
CONS_Printf(M_GetText("Errors occurred while loading %s; not added.\n"), filename);
|
||
|
||
return INT16_MAX;
|
||
}
|
||
|
||
|
||
// Allocate a wadfile, setup the lumpinfo (directory) and
|
||
// lumpcache, add the wadfile to the current active wadfiles
|
||
//
|
||
// now returns index into wadfiles[], you can get wadfile_t *
|
||
// with:
|
||
// wadfiles[<return value>]
|
||
//
|
||
// return -1 in case of problem
|
||
//
|
||
// Can now load dehacked files (.soc)
|
||
//
|
||
UINT16 W_InitFile(const char *filename, boolean local, boolean startup)
|
||
{
|
||
FILE *handle;
|
||
lumpinfo_t *lumpinfo = NULL;
|
||
wadfile_t *wadfile;
|
||
restype_t type;
|
||
UINT16 numlumps = 0;
|
||
#ifndef NOMD5
|
||
size_t i;
|
||
#endif
|
||
UINT8 md5sum[16];
|
||
int important;
|
||
|
||
if (!(refreshdirmenu & REFRESHDIR_ADDFILE))
|
||
refreshdirmenu = REFRESHDIR_NORMAL|REFRESHDIR_ADDFILE; // clean out cons_alerts that happened earlier
|
||
|
||
Z_Free(refreshdirname);
|
||
refreshdirname = NULL;
|
||
|
||
if (dirmenu)
|
||
{
|
||
refreshdirname = Z_StrDup(filename);
|
||
nameonly(refreshdirname);
|
||
}
|
||
|
||
CONS_Printf("Loading %s\n", filename);
|
||
|
||
//
|
||
// check if limit of active wadfiles
|
||
//
|
||
if (numwadfiles >= MAX_WADFILES)
|
||
{
|
||
CONS_Alert(CONS_ERROR, M_GetText("Maximum wad files reached\n"));
|
||
refreshdirmenu |= REFRESHDIR_MAX;
|
||
return W_InitFileError(filename, startup);
|
||
}
|
||
|
||
// open wad file
|
||
if ((handle = W_OpenWadFile(&filename, true)) == NULL)
|
||
return W_InitFileError(filename, startup);
|
||
|
||
if (local)
|
||
{
|
||
important = 0;
|
||
}
|
||
else
|
||
{
|
||
important = W_VerifyNMUSlumps(filename, handle, startup);
|
||
|
||
if (important == -1)
|
||
{
|
||
fclose(handle);
|
||
return INT16_MAX;
|
||
}
|
||
|
||
important = !important;
|
||
}
|
||
|
||
#ifndef NOMD5
|
||
//
|
||
// w-waiiiit!
|
||
// Let's not add a wad file if the MD5 matches
|
||
// an MD5 of an already added WAD file!
|
||
//
|
||
W_MakeFileMD5(filename, md5sum);
|
||
|
||
for (i = 0; i < numwadfiles; i++)
|
||
{
|
||
if (!memcmp(wadfiles[i]->md5sum, md5sum, 16))
|
||
{
|
||
CONS_Alert(CONS_ERROR, M_GetText("%s is already loaded\n"), filename);
|
||
fclose(handle);
|
||
return W_InitFileError(filename, false);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
type = ResourceFileDetect(filename);
|
||
|
||
switch (type)
|
||
{
|
||
case RET_SOC:
|
||
lumpinfo = ResGetLumpsStandalone(handle, &numlumps, "OBJCTCFG");
|
||
break;
|
||
case RET_LUA:
|
||
lumpinfo = ResGetLumpsStandalone(handle, &numlumps, "LUA_INIT");
|
||
break;
|
||
case RET_PK3:
|
||
lumpinfo = ResGetLumpsZip(handle, &numlumps);
|
||
break;
|
||
case RET_WAD:
|
||
lumpinfo = ResGetLumpsWad(handle, &numlumps, filename);
|
||
break;
|
||
default:
|
||
CONS_Alert(CONS_ERROR, "Unsupported file format\n");
|
||
}
|
||
|
||
if (lumpinfo == NULL)
|
||
{
|
||
fclose(handle);
|
||
return W_InitFileError(filename, startup);
|
||
}
|
||
|
||
//
|
||
// link wad file to search files
|
||
//
|
||
wadfile = (wadfile_t *)(Z_Calloc(sizeof (*wadfile), PU_STATIC, NULL));
|
||
wadfile->filename = Z_StrDup(filename);
|
||
wadfile->handle = handle;
|
||
wadfile->numlumps = (UINT16)(numlumps);
|
||
wadfile->lumpinfo = lumpinfo;
|
||
wadfile->important = important;
|
||
fseek(handle, 0, SEEK_END);
|
||
wadfile->filesize = (unsigned)(ftell(handle));
|
||
wadfile->type = type;
|
||
wadfile->startfolders = (FolderCache *)malloc(sizeof(FolderCache));
|
||
folder_map_init(&wadfile->startfolders->map);
|
||
wadfile->endfolders = (FolderCache *)malloc(sizeof(FolderCache));
|
||
folder_map_init(&wadfile->endfolders->map);
|
||
|
||
// already generated, just copy it over
|
||
memcpy(&wadfile->md5sum, &md5sum, 16);
|
||
|
||
//
|
||
// set up caching
|
||
//
|
||
Z_Calloc(numlumps * sizeof (*wadfile->lumpcache), PU_STATIC, &wadfile->lumpcache);
|
||
Z_Calloc(numlumps * sizeof (*wadfile->patchcache), PU_STATIC, &wadfile->patchcache);
|
||
|
||
#ifdef ROTSPRITE
|
||
Z_Calloc(numlumps * sizeof (*wadfile->rotcache), PU_STATIC, &wadfile->rotcache);
|
||
#endif
|
||
|
||
//
|
||
// add the wadfile
|
||
//
|
||
CONS_Printf(M_GetText("Added file %s (%u lumps)\n"), filename, numlumps);
|
||
wadfiles[numwadfiles] = wadfile;
|
||
numwadfiles++; // must come BEFORE W_LoadDehackedLumps, so any addfile called by COM_BufInsertText called by Lua doesn't overwrite what we just loaded
|
||
|
||
#ifdef HWRENDER
|
||
// Read shaders from file
|
||
if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
|
||
HWR_LoadCustomShadersFromFile(numwadfiles - 1, (boolean)(type == RET_PK3));
|
||
#endif
|
||
|
||
// TODO: HACK ALERT - Load Lua & SOC stuff right here. I feel like this should be out of this place, but... Let's stick with this for now.
|
||
switch (wadfile->type)
|
||
{
|
||
case RET_WAD:
|
||
W_LoadDehackedLumps(numwadfiles - 1);
|
||
break;
|
||
case RET_PK3:
|
||
W_LoadDehackedLumpsPK3(numwadfiles - 1);
|
||
break;
|
||
case RET_SOC:
|
||
CONS_Printf(M_GetText("Loading SOC from %s\n"), wadfile->filename);
|
||
DEH_LoadDehackedLumpPwad(numwadfiles - 1, 0);
|
||
break;
|
||
case RET_LUA:
|
||
LUA_LoadLump(numwadfiles - 1, 0);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (refreshdirmenu & REFRESHDIR_GAMEDATA)
|
||
G_LoadGameData();
|
||
|
||
DEH_UpdateMaxFreeslots();
|
||
W_InvalidateLumpnumCache();
|
||
|
||
return wadfile->numlumps;
|
||
}
|
||
|
||
/** Tries to load a series of files.
|
||
* All files are wads unless they have an extension of ".soc" or ".lua".
|
||
*
|
||
* Each file is optional, but at least one file must be found or an error will
|
||
* result. Lump names can appear multiple times. The name searcher looks
|
||
* backwards, so a later file overrides all earlier ones.
|
||
*
|
||
* \param filenames A null-terminated list of files to use.
|
||
* \return 1 if all files were loaded, 0 if at least one was missing or
|
||
* invalid.
|
||
*/
|
||
INT32 W_InitMultipleFiles(char **filenames, size_t count, boolean addons)
|
||
{
|
||
INT32 rc = 1;
|
||
INT32 overallrc = 1;
|
||
size_t i;
|
||
(void)addons;
|
||
|
||
for (i = 0; i < count; i++)
|
||
{
|
||
const char *filename = filenames[i];
|
||
|
||
// Previously, W_VerifyNMUSlumps was called to mark game modified
|
||
// for addons... but W_InitFile already does exactly that!
|
||
|
||
//CONS_Debug(DBG_SETUP, "Loading %s\n", *filenames);
|
||
rc = W_InitFile(filename, false, true);
|
||
|
||
if (rc == INT16_MAX)
|
||
CONS_Printf(M_GetText("Errors occurred while loading %s; not added.\n"), filename);
|
||
|
||
overallrc &= (rc != INT16_MAX) ? 1 : 0;
|
||
}
|
||
|
||
if (!numwadfiles)
|
||
I_Error("W_InitMultipleFiles: no files found");
|
||
|
||
return overallrc;
|
||
}
|
||
|
||
INT32 W_AddAutoloadedLocalFiles(char **filenames)
|
||
{
|
||
UINT16 rc = 1;
|
||
INT32 overallrc = 1;
|
||
|
||
// will be realloced as lumps are added
|
||
for (; *filenames; filenames++)
|
||
{
|
||
rc = P_PartialAddWadFile(*filenames, true);
|
||
|
||
if (rc == UINT16_MAX)
|
||
CONS_Printf(M_GetText("Errors occurred while loading %s; not added.\n"), *filenames);
|
||
|
||
overallrc &= (rc != UINT16_MAX) ? 1 : 0;
|
||
}
|
||
|
||
if (!numwadfiles)
|
||
I_Error("W_AddAutoloadedLocalFiles: no files found");
|
||
|
||
if (P_PartialAddGetStage() >= 0)
|
||
P_MultiSetupWadFiles(true);
|
||
|
||
return overallrc;
|
||
}
|
||
|
||
/** Make sure a lump number is valid.
|
||
* Compiles away to nothing if PARANOIA is not defined.
|
||
*/
|
||
static inline boolean TestValidLump(UINT16 wad, UINT16 lump)
|
||
{
|
||
I_Assert(wad < MAX_WADFILES);
|
||
if (!wadfiles[wad]) // make sure the wad file exists
|
||
return false;
|
||
|
||
I_Assert(lump < wadfiles[wad]->numlumps);
|
||
if (lump >= wadfiles[wad]->numlumps) // make sure the lump exists
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
const char *W_CheckNameForNumPwad(UINT16 wad, UINT16 lump)
|
||
{
|
||
if (!TestValidLump(wad, lump))
|
||
return NULL;
|
||
|
||
return wadfiles[wad]->lumpinfo[lump].name;
|
||
}
|
||
|
||
const char *W_CheckNameForNum(lumpnum_t lumpnum)
|
||
{
|
||
return W_CheckNameForNumPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum));
|
||
}
|
||
|
||
//
|
||
// Same as the original, but checks in one pwad only.
|
||
// wadid is a wad number
|
||
// (Used for sprites loading)
|
||
//
|
||
// 'startlump' is the lump number to start the search
|
||
//
|
||
UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||
{
|
||
UINT16 i;
|
||
static char uname[8 + 1];
|
||
UINT32 hash;
|
||
size_t namelen;
|
||
|
||
if (!TestValidLump(wad, 0))
|
||
return INT16_MAX;
|
||
|
||
memset(uname, 0, sizeof(uname));
|
||
strncpy(uname, name, sizeof(uname)-1);
|
||
strupr(uname);
|
||
namelen = strlen(uname);
|
||
hash = W_HashLumpName(uname);
|
||
|
||
//
|
||
// scan forward
|
||
// start at 'startlump', useful parameter when there are multiple
|
||
// resources with the same name
|
||
//
|
||
if (startlump < wadfiles[wad]->numlumps)
|
||
{
|
||
lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
|
||
|
||
for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
|
||
{
|
||
if (lump_p->namelength == namelen
|
||
&& lump_p->hash.name == hash
|
||
&& !memcmp(lump_p->name, uname, sizeof(uname) - 1))
|
||
return i;
|
||
}
|
||
}
|
||
|
||
// not found.
|
||
return INT16_MAX;
|
||
}
|
||
|
||
//
|
||
// Like W_CheckNumForNamePwad, but can find entries with long names
|
||
//
|
||
// Should be the only version, but that's not possible until we fix
|
||
// all the instances of non null-terminated strings in the codebase...
|
||
//
|
||
/*UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||
{
|
||
UINT16 i;
|
||
UINT32 hash;
|
||
size_t namelen;
|
||
|
||
if (!TestValidLump(wad, 0))
|
||
return INT16_MAX;
|
||
|
||
namelen = strlen(name);
|
||
hash = W_HashLumpName(name);
|
||
|
||
//
|
||
// scan forward
|
||
// start at 'startlump', useful parameter when there are multiple
|
||
// resources with the same name
|
||
//
|
||
if (startlump < wadfiles[wad]->numlumps)
|
||
{
|
||
lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
|
||
|
||
for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
|
||
{
|
||
if (lump_p->longnamelength == namelen
|
||
&& lump_p->hash.longname == hash
|
||
&& fasticmp(lump_p->longname, name))
|
||
return i;
|
||
}
|
||
}
|
||
|
||
// not found.
|
||
return INT16_MAX;
|
||
}*/
|
||
|
||
UINT16 W_CheckNumForMarkerStartPwad(const char *name, UINT16 wad, UINT16 startlump)
|
||
{
|
||
UINT16 marker;
|
||
|
||
marker = W_CheckNumForNamePwad(name, wad, startlump);
|
||
if (marker != INT16_MAX)
|
||
marker++; // Do not count the first marker
|
||
|
||
return marker;
|
||
}
|
||
|
||
// Look for the first lump from a folder.
|
||
UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlump)
|
||
{
|
||
UINT16 i;
|
||
size_t namelen;
|
||
lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
|
||
|
||
folder_map_itr it = folder_map_get(&wadfiles[wad]->startfolders->map, name);
|
||
if (!folder_map_is_end(it))
|
||
return it.data->val;
|
||
|
||
namelen = strlen(name);
|
||
|
||
for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
|
||
{
|
||
if (strnicmp(name, lump_p->fullname, namelen) == 0)
|
||
{
|
||
/* SLADE is special and puts a single directory entry. Skip that. */
|
||
if (lump_p->fullnamelength == namelen)
|
||
i++;
|
||
|
||
folder_map_insert(&wadfiles[wad]->startfolders->map, strdup(name), i);
|
||
return i;
|
||
}
|
||
}
|
||
|
||
folder_map_insert(&wadfiles[wad]->startfolders->map, strdup(name), INT16_MAX);
|
||
return INT16_MAX;
|
||
}
|
||
|
||
// In a PK3 type of resource file, it looks for the next lumpinfo entry that doesn't share the specified pathfile.
|
||
// Useful for finding folder ends.
|
||
// Returns the position of the lumpinfo entry.
|
||
UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump)
|
||
{
|
||
UINT16 i;
|
||
size_t namelen;
|
||
lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
|
||
|
||
folder_map_itr it = folder_map_get(&wadfiles[wad]->endfolders->map, name);
|
||
if (!folder_map_is_end(it))
|
||
return it.data->val;
|
||
|
||
namelen = strlen(name);
|
||
|
||
for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
|
||
{
|
||
if (strnicmp(name, lump_p->fullname, namelen))
|
||
break;
|
||
}
|
||
|
||
folder_map_insert(&wadfiles[wad]->endfolders->map, strdup(name), i);
|
||
return i;
|
||
}
|
||
|
||
// In a PK3 type of resource file, it looks for an entry with the specified full name.
|
||
// Returns lump position in PK3's lumpinfo, or INT16_MAX if not found.
|
||
UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump)
|
||
{
|
||
UINT16 i;
|
||
size_t namelen;
|
||
lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
|
||
|
||
namelen = strlen(name);
|
||
|
||
for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
|
||
{
|
||
if (!strnicmp(name, lump_p->fullname, namelen))
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
|
||
// Not found at all?
|
||
return INT16_MAX;
|
||
}
|
||
|
||
FUNCINLINE static ATTRINLINE lumpnum_t CheckLumpInCache(const char *name)
|
||
{
|
||
lumpnum_map_itr it = lumpnum_map_get(&lumpnumcache, name);
|
||
if (!lumpnum_map_is_end(it))
|
||
return it.data->val;
|
||
|
||
return LUMPERROR;
|
||
}
|
||
|
||
FUNCINLINE static ATTRINLINE void AddLumpToCache(lumpnum_t lumpnum, const char *name)
|
||
{
|
||
I_Assert(strnlen(name, 9) <= 8); // we dont have longnames, so assume this is a non terminated string
|
||
lumpnum_map_insert(&lumpnumcache, strdup(name), lumpnum);
|
||
}
|
||
|
||
//
|
||
// W_CheckNumForName
|
||
// Returns LUMPERROR if name not found.
|
||
//
|
||
lumpnum_t W_CheckNumForName(const char *name)
|
||
{
|
||
INT32 i;
|
||
lumpnum_t check = INT16_MAX;
|
||
|
||
if (!*name) // some doofus gave us an empty string?
|
||
return LUMPERROR;
|
||
|
||
// Check the lumpnumcache first.
|
||
lumpnum_t cachenum = CheckLumpInCache(name);
|
||
if (cachenum != LUMPERROR)
|
||
return cachenum;
|
||
|
||
// scan wad files backwards so patch lump files take precedence
|
||
for (i = numwadfiles - 1; i >= 0; i--)
|
||
{
|
||
check = W_CheckNumForNamePwad(name, (UINT16)(i), 0);
|
||
|
||
if (check != INT16_MAX)
|
||
break; //found it
|
||
}
|
||
|
||
if (check == INT16_MAX)
|
||
{
|
||
return LUMPERROR;
|
||
}
|
||
else
|
||
{
|
||
// Update the cache.
|
||
lumpnum_t lumpnum = (i << 16) | check;
|
||
AddLumpToCache(lumpnum, name);
|
||
|
||
return lumpnum;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Like W_CheckNumForName, but can find entries with long names
|
||
//
|
||
// Should be the only version, but that's not possible until we fix
|
||
// all the instances of non null-terminated strings in the codebase...
|
||
//
|
||
/*lumpnum_t W_CheckNumForLongName(const char *name)
|
||
{
|
||
INT32 i;
|
||
lumpnum_t check = INT16_MAX;
|
||
|
||
if (!*name) // some doofus gave us an empty string?
|
||
return LUMPERROR;
|
||
|
||
// Check the lumpnumcache first.
|
||
lumpnum_t cachenum = CheckLumpInCache(name);
|
||
if (cachenum != LUMPERROR)
|
||
return cachenum;
|
||
|
||
// scan wad files backwards so patch lump files take precedence
|
||
for (i = numwadfiles - 1; i >= 0; i--)
|
||
{
|
||
check = W_CheckNumForLongNamePwad(name, (UINT16)(i), 0);
|
||
|
||
if (check != INT16_MAX)
|
||
break; //found it
|
||
}
|
||
|
||
if (check == INT16_MAX)
|
||
{
|
||
return LUMPERROR;
|
||
}
|
||
else
|
||
{
|
||
// Update the cache.
|
||
lumpnum_t lumpnum = (i << 16) | check;
|
||
AddLumpToCache(lumpnum, name);
|
||
|
||
return lumpnum;
|
||
}
|
||
}*/
|
||
|
||
//
|
||
// W_GetNumForName
|
||
//
|
||
// Calls W_CheckNumForName, but bombs out if not found.
|
||
//
|
||
lumpnum_t W_GetNumForName(const char *name)
|
||
{
|
||
lumpnum_t i;
|
||
|
||
i = W_CheckNumForName(name);
|
||
|
||
if (i == LUMPERROR)
|
||
I_Error("W_GetNumForName: %s not found!\n", name);
|
||
|
||
return i;
|
||
}
|
||
|
||
//
|
||
// Like W_GetNumForName, but can find entries with long names
|
||
//
|
||
// Should be the only version, but that's not possible until we fix
|
||
// all the instances of non null-terminated strings in the codebase...
|
||
//
|
||
/*lumpnum_t W_GetNumForLongName(const char *name)
|
||
{
|
||
lumpnum_t i;
|
||
|
||
i = W_CheckNumForLongName(name);
|
||
|
||
if (i == LUMPERROR)
|
||
I_Error("W_GetNumForLongName: %s not found!\n", name);
|
||
|
||
return i;
|
||
}*/
|
||
|
||
//
|
||
// W_CheckNumForNameInBlock
|
||
// Checks only in blocks from blockstart lump to blockend lump
|
||
//
|
||
lumpnum_t W_CheckNumForNameInBlock(const char *name, const char *blockstart, const char *blockend)
|
||
{
|
||
INT32 i;
|
||
lumpnum_t bsid, beid;
|
||
lumpnum_t check = INT16_MAX;
|
||
|
||
// scan wad files backwards so patch lump files take precedence
|
||
for (i = numwadfiles - 1; i >= 0; i--)
|
||
{
|
||
if (wadfiles[i]->type == RET_WAD)
|
||
{
|
||
bsid = W_CheckNumForNamePwad(blockstart, (UINT16)(i), 0);
|
||
if (bsid == INT16_MAX)
|
||
continue; // Start block doesn't exist?
|
||
beid = W_CheckNumForNamePwad(blockend, (UINT16)(i), 0);
|
||
if (beid == INT16_MAX)
|
||
continue; // End block doesn't exist?
|
||
|
||
check = W_CheckNumForNamePwad(name, (UINT16)(i), bsid);
|
||
if (check < beid)
|
||
return (i << 16)+check; // found it, in our constraints
|
||
}
|
||
}
|
||
|
||
return LUMPERROR;
|
||
}
|
||
|
||
// Used by Lua. Case sensitive lump checking, quickly...
|
||
UINT8 W_LumpExists(const char *name)
|
||
{
|
||
INT32 i, j;
|
||
UINT32 hash;
|
||
size_t namelen;
|
||
|
||
// Check the lumpnumcache first.
|
||
lumpnum_t cachenum = CheckLumpInCache(name);
|
||
if (cachenum != LUMPERROR)
|
||
return true;
|
||
|
||
namelen = strlen(name);
|
||
hash = W_HashLumpName(name);
|
||
|
||
for (i = numwadfiles - 1; i >= 0; i--)
|
||
{
|
||
lumpinfo_t *lump_p = wadfiles[i]->lumpinfo;
|
||
for (j = 0; j < wadfiles[i]->numlumps; ++j, ++lump_p)
|
||
{
|
||
if (lump_p->namelength == namelen
|
||
&& lump_p->hash.name == hash
|
||
&& fastcmp(lump_p->name, name))
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
UINT8 W_CheckMultipleLumps(const char* lump, ...)
|
||
{
|
||
va_list lumps;
|
||
va_start(lumps, lump);
|
||
const char* lumpname = lump;
|
||
|
||
while (lumpname != NULL)
|
||
{
|
||
if (!W_LumpExists(lumpname))
|
||
{
|
||
va_end(lumps);
|
||
return false;
|
||
}
|
||
lumpname = va_arg(lumps, const char*);
|
||
}
|
||
|
||
va_end(lumps);
|
||
return true;
|
||
}
|
||
|
||
size_t W_LumpLengthPwad(UINT16 wad, UINT16 lump)
|
||
{
|
||
if (!TestValidLump(wad, lump))
|
||
return 0;
|
||
|
||
return wadfiles[wad]->lumpinfo[lump].size;
|
||
}
|
||
|
||
/** Returns the buffer size needed to load the given lump.
|
||
*
|
||
* \param lump Lump number to look at.
|
||
* \return Buffer size needed, in bytes.
|
||
*/
|
||
size_t W_LumpLength(lumpnum_t lumpnum)
|
||
{
|
||
return W_LumpLengthPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum));
|
||
}
|
||
|
||
//
|
||
// W_IsLumpWad
|
||
// Is the lump a WAD? (presumably in a PK3)
|
||
//
|
||
boolean W_IsLumpWad(lumpnum_t lumpnum)
|
||
{
|
||
if (wadfiles[WADFILENUM(lumpnum)]->type == RET_PK3)
|
||
{
|
||
const char *lumpfullName = (wadfiles[WADFILENUM(lumpnum)]->lumpinfo + LUMPNUM(lumpnum))->fullname;
|
||
|
||
size_t len = strlen(lumpfullName);
|
||
|
||
if (len < 4)
|
||
return false; // can't possibly be a WAD can it?
|
||
return !strnicmp(lumpfullName + len - 4, ".wad", 4);
|
||
}
|
||
|
||
return false; // WADs should never be inside non-PK3s as far as SRB2 is concerned
|
||
}
|
||
|
||
//
|
||
// W_IsLumpFolder
|
||
// Is the lump a folder? (not in a WAD obviously)
|
||
//
|
||
boolean W_IsLumpFolder(UINT16 wad, UINT16 lump)
|
||
{
|
||
if (W_FileHasFolders(wadfiles[wad]))
|
||
{
|
||
const char *name = wadfiles[wad]->lumpinfo[lump].fullname;
|
||
return (name[strlen(name)-1] == '/'); // folders end in '/'
|
||
}
|
||
|
||
return false; // WADs don't have folders
|
||
}
|
||
|
||
#ifdef HAVE_ZLIB
|
||
/* report a zlib or i/o error */
|
||
void zerr(int ret)
|
||
{
|
||
CONS_Printf("zpipe: ");
|
||
|
||
switch (ret)
|
||
{
|
||
case Z_ERRNO:
|
||
if (ferror(stdin))
|
||
CONS_Printf("error reading stdin\n");
|
||
if (ferror(stdout))
|
||
CONS_Printf("error writing stdout\n");
|
||
break;
|
||
case Z_STREAM_ERROR:
|
||
CONS_Printf("invalid compression level\n");
|
||
break;
|
||
case Z_DATA_ERROR:
|
||
CONS_Printf("invalid or incomplete deflate data\n");
|
||
break;
|
||
case Z_MEM_ERROR:
|
||
CONS_Printf("out of memory\n");
|
||
break;
|
||
case Z_VERSION_ERROR:
|
||
CONS_Printf("zlib version mismatch!\n");
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#define NO_PNG_LUMPS
|
||
|
||
#ifdef NO_PNG_LUMPS
|
||
static void ErrorIfPNG(UINT8 *d, size_t s, char *f, char *l)
|
||
{
|
||
if (s < 67) // http://garethrees.org/2007/11/14/pngcrush/
|
||
return;
|
||
// Check for PNG file signature using memcmp
|
||
// As it may be faster on CPUs with slow unaligned memory access
|
||
// Ref: http://www.libpng.org/pub/png/spec/1.2/PNG-Rationale.html#R.PNG-file-signature
|
||
if (memcmp(&d[0], "\x89\x50\x4e\x47\x0d\x0a\x1a\x0a", 8) == 0)
|
||
{
|
||
I_Error("W_Wad: Lump \"%s\" in file \"%s\" is a .PNG - please convert to either Doom or Flat (raw) image format.", l, f);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/** Reads bytes from the head of a lump.
|
||
* Note: If the lump is compressed, the whole thing has to be read anyway.
|
||
*
|
||
* \param wad Wad number to read from.
|
||
* \param lump Lump number to read from.
|
||
* \param dest Buffer in memory to serve as destination.
|
||
* \param size Number of bytes to read.
|
||
* \param offest Number of bytes to offset.
|
||
* \return Number of bytes read (should equal size).
|
||
* \sa W_ReadLump, W_RawReadLumpHeader
|
||
*/
|
||
size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, size_t offset)
|
||
{
|
||
size_t lumpsize;
|
||
lumpinfo_t *l;
|
||
FILE *handle;
|
||
|
||
if (!TestValidLump(wad,lump))
|
||
return 0;
|
||
|
||
lumpsize = wadfiles[wad]->lumpinfo[lump].size;
|
||
|
||
// empty resource (usually markers like S_START, F_END ..)
|
||
if (!lumpsize || lumpsize < offset)
|
||
return 0;
|
||
|
||
// zero size means read all the lump
|
||
if (!size || size+offset > lumpsize)
|
||
size = lumpsize - offset;
|
||
|
||
// Let's get the raw lump data.
|
||
// We setup the desired file handle to read the lump data.
|
||
l = wadfiles[wad]->lumpinfo + lump;
|
||
handle = wadfiles[wad]->handle;
|
||
fseek(handle, (long)(l->position + offset), SEEK_SET);
|
||
|
||
// But let's not copy it yet. We support different compression formats on lumps, so we need to take that into account.
|
||
switch (wadfiles[wad]->lumpinfo[lump].compression)
|
||
{
|
||
case CM_NOCOMPRESSION: // If it's uncompressed, we directly write the data into our destination, and return the bytes read.
|
||
#ifdef NO_PNG_LUMPS
|
||
{
|
||
size_t bytesread = fread(dest, 1, size, handle);
|
||
ErrorIfPNG((UINT8 *)(dest), bytesread, wadfiles[wad]->filename, l->fullname);
|
||
return bytesread;
|
||
}
|
||
#else
|
||
return fread(dest, 1, size, handle);
|
||
#endif
|
||
case CM_LZF: // Is it LZF compressed? Used by ZWADs.
|
||
{
|
||
#ifdef ZWAD
|
||
char *rawData; // The lump's raw data.
|
||
char *decData; // Lump's decompressed real data.
|
||
size_t retval; // Helper var, lzf_decompress returns 0 when an error occurs.
|
||
|
||
rawData = (char *)(Z_Malloc(l->disksize, PU_STATIC, NULL));
|
||
decData = (char *)(Z_Malloc(l->size, PU_STATIC, NULL));
|
||
|
||
if (fread(rawData, 1, l->disksize, handle) < l->disksize)
|
||
I_Error("wad %d, lump %d: cannot read compressed data", wad, lump);
|
||
retval = lzf_decompress(rawData, l->disksize, decData, l->size);
|
||
#ifndef AVOID_ERRNO
|
||
if (retval == 0) // If this was returned, check if errno was set
|
||
{
|
||
// errno is a global var set by the lzf functions when something goes wrong.
|
||
if (errno == E2BIG)
|
||
I_Error("wad %d, lump %d: compressed data too big (bigger than %s)", wad, lump, sizeu1(l->size));
|
||
else if (errno == EINVAL)
|
||
I_Error("wad %d, lump %d: invalid compressed data", wad, lump);
|
||
}
|
||
// Otherwise, fall back on below error (if zero was actually the correct size then ???)
|
||
#endif
|
||
if (retval != l->size)
|
||
{
|
||
I_Error("wad %d, lump %d: decompressed to wrong number of bytes (expected %s, got %s)", wad, lump, sizeu1(l->size), sizeu2(retval));
|
||
}
|
||
|
||
if (!decData) // Did we get no data at all?
|
||
return 0;
|
||
memcpy(dest, decData + offset, size);
|
||
Z_Free(rawData);
|
||
Z_Free(decData);
|
||
#ifdef NO_PNG_LUMPS
|
||
ErrorIfPNG((UINT8 *)(dest), size, wadfiles[wad]->filename, l->fullname);
|
||
#endif
|
||
return size;
|
||
#else
|
||
//I_Error("ZWAD files not supported on this platform.");
|
||
return 0;
|
||
#endif
|
||
|
||
}
|
||
#ifdef HAVE_ZLIB
|
||
case CM_DEFLATE: // Is it compressed via DEFLATE? Very common in ZIPs/PK3s, also what most doom-related editors support.
|
||
{
|
||
UINT8 *rawData; // The lump's raw data.
|
||
UINT8 *decData; // Lump's decompressed real data.
|
||
|
||
int zErr; // Helper var.
|
||
z_stream strm;
|
||
unsigned long rawSize = l->disksize;
|
||
unsigned long decSize = size;
|
||
|
||
rawData = (UINT8 *)(Z_Malloc(rawSize, PU_STATIC, NULL));
|
||
decData = (UINT8 *)(dest);
|
||
|
||
if (fread(rawData, 1, rawSize, handle) < rawSize)
|
||
I_Error("wad %d, lump %d: cannot read compressed data", wad, lump);
|
||
|
||
strm.zalloc = NULL;
|
||
strm.zfree = NULL;
|
||
strm.opaque = NULL;
|
||
|
||
strm.total_in = strm.avail_in = rawSize;
|
||
strm.total_out = strm.avail_out = decSize;
|
||
|
||
strm.next_in = rawData;
|
||
strm.next_out = decData;
|
||
|
||
zErr = inflateInit2(&strm, -15);
|
||
if (zErr == Z_OK)
|
||
{
|
||
zErr = inflate(&strm, Z_SYNC_FLUSH);
|
||
if (zErr != Z_OK && zErr != Z_STREAM_END)
|
||
{
|
||
size = 0;
|
||
zerr(zErr);
|
||
}
|
||
(void)inflateEnd(&strm);
|
||
}
|
||
else
|
||
{
|
||
CONS_Printf("whopet\n");
|
||
size = 0;
|
||
zerr(zErr);
|
||
}
|
||
|
||
Z_Free(rawData);
|
||
|
||
#ifdef NO_PNG_LUMPS
|
||
ErrorIfPNG((UINT8 *)(dest), size, wadfiles[wad]->filename, l->fullname);
|
||
#endif
|
||
return size;
|
||
}
|
||
#endif
|
||
default:
|
||
I_Error("wad %d, lump %d: unsupported compression type!", wad, lump);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
size_t W_ReadLumpHeader(lumpnum_t lumpnum, void *dest, size_t size, size_t offset)
|
||
{
|
||
return W_ReadLumpHeaderPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum), dest, size, offset);
|
||
}
|
||
|
||
/** Reads a lump into memory.
|
||
*
|
||
* \param lump Lump number to read from.
|
||
* \param dest Buffer in memory to serve as destination. Size must be >=
|
||
* W_LumpLength().
|
||
* \sa W_ReadLumpHeader
|
||
*/
|
||
void W_ReadLump(lumpnum_t lumpnum, void *dest)
|
||
{
|
||
W_ReadLumpHeaderPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum), dest, 0, 0);
|
||
}
|
||
|
||
void W_ReadLumpPwad(UINT16 wad, UINT16 lump, void *dest)
|
||
{
|
||
W_ReadLumpHeaderPwad(wad, lump, dest, 0, 0);
|
||
}
|
||
|
||
// ==========================================================================
|
||
// W_CacheLumpNum
|
||
// ==========================================================================
|
||
void *W_CacheLumpNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
|
||
{
|
||
lumpcache_t *lumpcache;
|
||
|
||
if (!TestValidLump(wad, lump))
|
||
return NULL;
|
||
|
||
lumpcache = wadfiles[wad]->lumpcache;
|
||
if (!lumpcache[lump])
|
||
{
|
||
void *ptr = Z_Malloc(W_LumpLengthPwad(wad, lump), tag, &lumpcache[lump]);
|
||
W_ReadLumpHeaderPwad(wad, lump, ptr, 0, 0); // read the lump in full
|
||
}
|
||
else
|
||
Z_ChangeTag(lumpcache[lump], tag);
|
||
|
||
return lumpcache[lump];
|
||
}
|
||
|
||
void *W_CacheLumpNum(lumpnum_t lumpnum, INT32 tag)
|
||
{
|
||
return W_CacheLumpNumPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum),tag);
|
||
}
|
||
|
||
//
|
||
// W_CacheLumpNumForce
|
||
//
|
||
// Forces the lump to be loaded, even if it already is!
|
||
//
|
||
void *W_CacheLumpNumForce(lumpnum_t lumpnum, INT32 tag)
|
||
{
|
||
UINT16 wad, lump;
|
||
void *ptr;
|
||
|
||
wad = WADFILENUM(lumpnum);
|
||
lump = LUMPNUM(lumpnum);
|
||
|
||
if (!TestValidLump(wad, lump))
|
||
return NULL;
|
||
|
||
ptr = Z_Malloc(W_LumpLengthPwad(wad, lump), tag, NULL);
|
||
W_ReadLumpHeaderPwad(wad, lump, ptr, 0, 0); // read the lump in full
|
||
|
||
return ptr;
|
||
}
|
||
|
||
//
|
||
// W_IsLumpCached
|
||
//
|
||
// If a lump is already cached return true, otherwise
|
||
// return false.
|
||
//
|
||
// no outside code uses the PWAD form, for now
|
||
static inline boolean W_IsLumpCachedPWAD(UINT16 wad, UINT16 lump, void *ptr)
|
||
{
|
||
void *lcache;
|
||
|
||
if (!TestValidLump(wad, lump))
|
||
return false;
|
||
|
||
lcache = wadfiles[wad]->lumpcache[lump];
|
||
|
||
if (ptr)
|
||
{
|
||
if (ptr == lcache)
|
||
return true;
|
||
}
|
||
else if (lcache)
|
||
return true;
|
||
|
||
return false;
|
||
}
|
||
|
||
boolean W_IsLumpCached(lumpnum_t lumpnum, void *ptr)
|
||
{
|
||
return W_IsLumpCachedPWAD(WADFILENUM(lumpnum), LUMPNUM(lumpnum), ptr);
|
||
}
|
||
|
||
//
|
||
// W_IsPatchCached
|
||
//
|
||
// If a patch is already cached return true, otherwise
|
||
// return false.
|
||
//
|
||
// no outside code uses the PWAD form, for now
|
||
static inline boolean W_IsPatchCachedPWAD(UINT16 wad, UINT16 lump, void *ptr)
|
||
{
|
||
void *lcache;
|
||
|
||
if (!TestValidLump(wad, lump))
|
||
return false;
|
||
|
||
lcache = wadfiles[wad]->patchcache[lump];
|
||
|
||
if (ptr)
|
||
{
|
||
if (ptr == lcache)
|
||
return true;
|
||
}
|
||
else if (lcache)
|
||
return true;
|
||
|
||
return false;
|
||
}
|
||
|
||
boolean W_IsPatchCached(lumpnum_t lumpnum, void *ptr)
|
||
{
|
||
return W_IsPatchCachedPWAD(WADFILENUM(lumpnum), LUMPNUM(lumpnum), ptr);
|
||
}
|
||
|
||
|
||
// ==========================================================================
|
||
// W_CacheLumpName
|
||
// ==========================================================================
|
||
void *W_CacheLumpName(const char *name, INT32 tag)
|
||
{
|
||
return W_CacheLumpNum(W_GetNumForName(name), tag);
|
||
}
|
||
|
||
// ==========================================================================
|
||
// CACHING OF GRAPHIC PATCH RESOURCES
|
||
// ==========================================================================
|
||
|
||
// Graphic 'patches' are loaded, and if necessary, converted into the format
|
||
// the most useful for the current rendermode. For software renderer, the
|
||
// graphic patches are kept as is. For the hardware renderer, graphic patches
|
||
// are 'unpacked', and are kept into the cache in that unpacked format, and
|
||
// the heap memory cache then acts as a 'level 2' cache just after the
|
||
// graphics card memory.
|
||
|
||
//
|
||
// Cache a patch into heap memory, convert the patch format as necessary
|
||
//
|
||
|
||
void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
|
||
{
|
||
lumpcache_t *lumpcache = NULL;
|
||
|
||
if (!TestValidLump(wad, lump))
|
||
return NULL;
|
||
|
||
lumpcache = wadfiles[wad]->patchcache;
|
||
|
||
if (!lumpcache[lump])
|
||
{
|
||
size_t len = W_LumpLengthPwad(wad, lump);
|
||
void *dest, *lumpdata = Z_Malloc(len, PU_STATIC, NULL);
|
||
|
||
// read the lump in full
|
||
W_ReadLumpHeaderPwad(wad, lump, lumpdata, 0, 0);
|
||
|
||
dest = Z_Calloc(sizeof(patch_t), tag, &lumpcache[lump]);
|
||
Patch_Create((softwarepatch_t *)(lumpdata), len, dest);
|
||
|
||
Z_Free(lumpdata);
|
||
}
|
||
else
|
||
Z_ChangeTag(lumpcache[lump], tag);
|
||
|
||
return lumpcache[lump];
|
||
}
|
||
|
||
void *W_CacheSoftwarePatchNum(lumpnum_t lumpnum, INT32 tag)
|
||
{
|
||
return W_CacheSoftwarePatchNumPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum), tag);
|
||
}
|
||
|
||
void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
|
||
{
|
||
patch_t *patch;
|
||
|
||
if (!TestValidLump(wad, lump))
|
||
return NULL;
|
||
|
||
patch = (patch_t *)(W_CacheSoftwarePatchNumPwad(wad, lump, tag));
|
||
|
||
if (patch == NULL)
|
||
return NULL;
|
||
|
||
#ifdef HWRENDER
|
||
// Software-only compile cache the data without conversion
|
||
if (rendermode == render_opengl)
|
||
Patch_CreateGL(patch);
|
||
#endif
|
||
|
||
return (void*)(patch);
|
||
}
|
||
|
||
void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag)
|
||
{
|
||
return W_CachePatchNumPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum), tag);
|
||
}
|
||
|
||
void *W_GetCachedPatchNumPwad(UINT16 wad, UINT16 lump)
|
||
{
|
||
if (!TestValidLump(wad, lump))
|
||
return NULL;
|
||
|
||
return wadfiles[wad]->patchcache[lump];
|
||
}
|
||
|
||
#ifdef ROTSPRITE
|
||
// Caches a rotsprite for patch rotation.
|
||
void *W_GetCachedRotPatchPwad(UINT16 wad, UINT16 lump)
|
||
{
|
||
if (!TestValidLump(wad, lump))
|
||
return NULL;
|
||
|
||
lumpcache_t *rotcache = wadfiles[wad]->rotcache;
|
||
|
||
if (!rotcache[lump])
|
||
{
|
||
rotsprite_t *rspr = RotatedPatch_Create(ROTANGLES);
|
||
Z_SetUser(rspr, (void**)(&rotcache[lump]));
|
||
}
|
||
|
||
return (void*)(rotcache[lump]);
|
||
}
|
||
#endif // ROTSPRITE
|
||
|
||
void W_UnlockCachedPatch(void *patch)
|
||
{
|
||
if (!patch)
|
||
return;
|
||
|
||
// The hardware code does its own memory management, as its patches
|
||
// have different lifetimes from software's.
|
||
#ifdef HWRENDER
|
||
if (rendermode == render_opengl)
|
||
HWR_UnlockCachedPatch((GLPatch_t *)(((patch_t *)(patch))->hardware));
|
||
else
|
||
#endif
|
||
Z_ChangeTag(patch, PU_PATCH);
|
||
}
|
||
|
||
void *W_CachePatchName(const char *name, INT32 tag)
|
||
{
|
||
lumpnum_t num;
|
||
|
||
num = W_CheckNumForName(name);
|
||
|
||
if (num == LUMPERROR)
|
||
return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
|
||
return W_CachePatchNum(num, tag);
|
||
}
|
||
|
||
#ifdef ROTSPRITE
|
||
// Caches a patch, and if needed, rotates said patch.
|
||
void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag)
|
||
{
|
||
lumpnum_t num;
|
||
patch_t *ptr;
|
||
rotsprite_t *rspr;
|
||
INT32 idx = rotationangle;
|
||
|
||
num = W_CheckNumForName(name);
|
||
|
||
if (num == LUMPERROR)
|
||
num = W_GetNumForName("MISSING");
|
||
|
||
// No rotation? No need to do any of this nonsense.
|
||
if (rotationangle < 1 || rotationangle >= ROTANGLES)
|
||
return W_CachePatchNum(num, tag);
|
||
|
||
rspr = (rotsprite_t *)(W_GetCachedRotPatchPwad(WADFILENUM(num), LUMPNUM(num)));
|
||
|
||
if (rspr == NULL)
|
||
return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
|
||
|
||
if (rspr->patches[idx] == NULL)
|
||
{
|
||
INT32 xpivot = 0, ypivot = 0;
|
||
|
||
ptr = (patch_t *)(W_CachePatchNum(num, PU_PATCH));
|
||
if (ptr == NULL)
|
||
return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
|
||
|
||
// >y pivot centered
|
||
// >x pivot not centered
|
||
// Why?
|
||
xpivot = ptr->width / 2;
|
||
ypivot = ptr->height / 2;
|
||
|
||
RotatedPatch_DoRotation(rspr, ptr, rotationangle, xpivot, ypivot, false);
|
||
}
|
||
|
||
return rspr->patches[idx];
|
||
}
|
||
#endif
|
||
|
||
#ifndef NOMD5
|
||
|
||
/**
|
||
* Prints an MD5 string into a human-readable textual format.
|
||
*
|
||
* \param md5 The md5 in binary form -- MD5_LEN (16) bytes.
|
||
* \param buf Where to print the textual form. Needs 2*MD5_LEN+1 (33) bytes.
|
||
* \author Graue <graue@oceanbase.org>
|
||
*/
|
||
#define MD5_FORMAT \
|
||
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
|
||
static void PrintMD5String(const UINT8 *md5, char *buf)
|
||
{
|
||
snprintf(buf, 2*MD5_LEN+1, MD5_FORMAT,
|
||
md5[0], md5[1], md5[2], md5[3],
|
||
md5[4], md5[5], md5[6], md5[7],
|
||
md5[8], md5[9], md5[10], md5[11],
|
||
md5[12], md5[13], md5[14], md5[15]);
|
||
}
|
||
#endif
|
||
/** Verifies a file's MD5 is as it should be.
|
||
* For releases, used as cheat prevention -- if the MD5 doesn't match, a
|
||
* fatal error is thrown. In debug mode, an MD5 mismatch only triggers a
|
||
* warning.
|
||
*
|
||
* \param wadfilenum Number of the loaded wad file to check.
|
||
* \param matchmd5 The MD5 sum this wad should have, expressed as a
|
||
* textual string.
|
||
* \author Graue <graue@oceanbase.org>
|
||
*/
|
||
void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5)
|
||
{
|
||
#ifdef NOMD5
|
||
(void)wadfilenum;
|
||
(void)matchmd5;
|
||
#else
|
||
UINT8 realmd5[MD5_LEN];
|
||
INT32 ix;
|
||
|
||
I_Assert(strlen(matchmd5) == 2*MD5_LEN);
|
||
I_Assert(wadfilenum < numwadfiles);
|
||
|
||
// Convert an md5 string like "7d355827fa8f981482246d6c95f9bd48"
|
||
// into a real md5.
|
||
for (ix = 0; ix < 2*MD5_LEN; ix++)
|
||
{
|
||
INT32 n, c = matchmd5[ix];
|
||
|
||
if (isdigit(c))
|
||
n = c - '0';
|
||
else
|
||
{
|
||
I_Assert(isxdigit(c));
|
||
if (isupper(c)) n = c - 'A' + 10;
|
||
else n = c - 'a' + 10;
|
||
}
|
||
|
||
if (ix & 1)
|
||
realmd5[ix>>1] = (UINT8)(realmd5[ix>>1]+n);
|
||
else
|
||
realmd5[ix>>1] = (UINT8)(n<<4);
|
||
}
|
||
|
||
if (memcmp(realmd5, wadfiles[wadfilenum]->md5sum, 16))
|
||
{
|
||
char actualmd5text[2*MD5_LEN+1];
|
||
PrintMD5String(wadfiles[wadfilenum]->md5sum, actualmd5text);
|
||
#ifdef _DEBUG
|
||
CONS_Printf
|
||
#else
|
||
I_Error
|
||
#endif
|
||
(M_GetText("File is corrupt or has been modified: %s (found md5: %s, wanted: %s)\n"), wadfiles[wadfilenum]->filename, actualmd5text, matchmd5);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
// Verify versions for different archive
|
||
// formats. checklist assumed to be valid.
|
||
static int W_VerifyName(const char *name, lumpchecklist_t *checklist, boolean status)
|
||
{
|
||
for (size_t j = 0; checklist[j].len && checklist[j].name; ++j)
|
||
{
|
||
if ((strncasecmp(name, checklist[j].name,
|
||
checklist[j].len) != false) == status)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
static int W_VerifyWAD(FILE *fp, lumpchecklist_t *checklist, boolean status)
|
||
{
|
||
size_t i, j;
|
||
// if we're here it's a WAD file
|
||
wadinfo_t header;
|
||
filelump_t lumpinfo;
|
||
|
||
// read the header
|
||
if (fread(&header, 1, sizeof header, fp) == sizeof header
|
||
&& header.numlumps < INT16_MAX
|
||
&& strncmp(header.identification, "ZWAD", 4)
|
||
&& strncmp(header.identification, "IWAD", 4)
|
||
&& strncmp(header.identification, "PWAD", 4)
|
||
&& strncmp(header.identification, "SDLL", 4))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
header.numlumps = LONG(header.numlumps);
|
||
header.infotableofs = LONG(header.infotableofs);
|
||
|
||
// let seek to the lumpinfo list
|
||
if (fseek(fp, header.infotableofs, SEEK_SET) == -1)
|
||
return true;
|
||
|
||
for (i = 0; i < header.numlumps; i++)
|
||
{
|
||
// fill in lumpinfo for this wad file directory
|
||
if (fread(&lumpinfo, sizeof (lumpinfo), 1 , fp) != 1)
|
||
return -1;
|
||
|
||
lumpinfo.filepos = LONG(lumpinfo.filepos);
|
||
lumpinfo.size = LONG(lumpinfo.size);
|
||
|
||
if (lumpinfo.size == 0)
|
||
continue;
|
||
|
||
for (j = 0; j < NUMSPRITES; j++)
|
||
if (!strncmp(lumpinfo.name, sprnames[j], 4)) // Sprites
|
||
continue;
|
||
|
||
if (!W_VerifyName(lumpinfo.name, checklist, status))
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// List of blacklisted folders to use when checking the PK3
|
||
static lumpchecklist_t folderblacklist[] =
|
||
{
|
||
{"Lua/", 4},
|
||
{"SOC/", 4},
|
||
{"Sprites/", 8},
|
||
{"Textures/", 9},
|
||
{"Patches/", 8},
|
||
{"Flats/", 6},
|
||
{"Fades/", 6},
|
||
{NULL, 0},
|
||
};
|
||
|
||
static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
|
||
{
|
||
int verified = true;
|
||
|
||
zend_t zend;
|
||
zlentry_t zlentry;
|
||
|
||
long file_size;/* size of zip file */
|
||
long data_size;/* size of data inside zip file */
|
||
|
||
UINT16 numlumps;
|
||
size_t i;
|
||
|
||
char lumpname[9];
|
||
|
||
// Haha the ResGetLumpsZip function doesn't
|
||
// check for file errors, so neither will I.
|
||
|
||
// Central directory bullshit
|
||
|
||
fseek(fp, 0, SEEK_END);
|
||
file_size = ftell(fp);
|
||
|
||
const long startpos = file_size - (22 + 65536);
|
||
if (!ResFindSignature(fp, pat_end, max(0l, startpos)))
|
||
return true;
|
||
|
||
fseek(fp, -4, SEEK_CUR);
|
||
if (fread(&zend, 1, sizeof zend, fp) < sizeof zend)
|
||
return true;
|
||
|
||
data_size = sizeof zend;
|
||
|
||
numlumps = SHORT(zend.entries);
|
||
|
||
fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
|
||
|
||
CLEANUP(pfree) char *cdir = (char *)(malloc(LONG(zend.cdirsize)));
|
||
|
||
if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
size_t offset = 0;
|
||
|
||
for (i = 0; i < numlumps; i++)
|
||
{
|
||
zentry_t *zentry = (zentry_t *)(cdir + offset);
|
||
char* fullname;
|
||
char* trimname;
|
||
char* dotpos;
|
||
|
||
if (memcmp(zentry->signature, pat_central, 4) != 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (verified == true)
|
||
{
|
||
fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
|
||
strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
|
||
fullname[zentry->namelen] = 0;
|
||
|
||
// Strip away file address and extension for the 8char name.
|
||
if ((trimname = strrchr(fullname, '/')) != NULL)
|
||
trimname++;
|
||
else
|
||
trimname = fullname; // Care taken for root files.
|
||
|
||
if (*trimname) // Ignore directories, well kinda
|
||
{
|
||
if ((dotpos = strrchr(trimname, '.')) == NULL)
|
||
dotpos = fullname + strlen(fullname); // Watch for files without extension.
|
||
|
||
memset(lumpname, '\0', 9); // Making sure they're initialized to 0. Is it necessary?
|
||
strncpy(lumpname, trimname, min(8, dotpos - trimname));
|
||
|
||
if (!W_VerifyName(lumpname, checklist, status))
|
||
verified = false;
|
||
|
||
// Check for directories next, if it's blacklisted it will return false
|
||
else if (W_VerifyName(fullname, folderblacklist, status))
|
||
verified = false;
|
||
}
|
||
|
||
free(fullname);
|
||
}
|
||
|
||
offset += sizeof *zentry + SHORT(zentry->namelen) + SHORT(zentry->xtralen) + SHORT(zentry->commlen);
|
||
|
||
data_size +=
|
||
sizeof *zentry + SHORT(zentry->namelen) + SHORT(zentry->xtralen) + SHORT(zentry->commlen);
|
||
|
||
if (fseek(fp, LONG(zentry->offset), SEEK_SET) != 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (fread(&zlentry, 1, sizeof(zlentry_t), fp) < sizeof (zlentry_t))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
data_size +=
|
||
sizeof zlentry + SHORT(zlentry.namelen) + SHORT(zlentry.xtralen) + LONG(zlentry.compsize);
|
||
}
|
||
|
||
if (data_size < file_size)
|
||
{
|
||
const char * error = "ZIP file has holes (%ld extra bytes)\n";
|
||
CONS_Alert(CONS_ERROR, error, (file_size - data_size));
|
||
return -1;
|
||
}
|
||
else if (data_size > file_size)
|
||
{
|
||
const char * error = "Reported size of ZIP file contents exceeds file size (%ld extra bytes)\n";
|
||
CONS_Alert(CONS_ERROR, error, (data_size - file_size));
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
return verified;
|
||
}
|
||
}
|
||
|
||
/** Checks a wad for lumps other than music and sound.
|
||
* Used during game load to verify music.dta is a good file and during a
|
||
* netgame join (on the server side) to see if a wad is important enough to
|
||
* be sent.
|
||
*
|
||
* \param filename Filename of the wad to check.
|
||
* \return 1 if file contains only music/sound lumps, 0 if it contains other
|
||
* stuff (maps, sprites, dehacked lumps, and so on). -1 if there no
|
||
* file exists with that filename
|
||
* \author Alam Arias
|
||
*/
|
||
int W_VerifyNMUSlumps(const char *filename, FILE *handle, boolean exit_on_error)
|
||
{
|
||
static lumpchecklist_t NMUSlist[] =
|
||
{
|
||
{"D_", 2}, // MIDI music
|
||
{"O_", 2}, // Digital music
|
||
{"DS", 2}, // Sound effects
|
||
|
||
{"ENDOOM", 6}, // ENDOOM text lump
|
||
{"PLAYPAL", 7}, // Palette
|
||
{"COLORMAP", 8}, // Colormap
|
||
{"PAL", 3}, // Palette changes
|
||
{"CLM", 3}, // Colormap changes
|
||
{"TRANS", 5}, // Translucency map
|
||
|
||
{"LTFNT", 5}, // Level title font changes
|
||
{"TTL", 3}, // Act number changes
|
||
{"STCFN", 5}, // Console font changes
|
||
{"TNYFN", 5}, // Tiny console font changes
|
||
{"SBO", 3}, // Acceptable HUD changes (Score Time Rings)
|
||
{"RRINGS", 6}, // Rings HUD (not named as SBO)
|
||
{"YB_", 3}, // Intermission graphics, goes with the above
|
||
{"M_", 2}, // As does menu stuff
|
||
{"MKFNT", 5}, // Kart font changes
|
||
{"K_", 2}, // Kart graphic changes
|
||
{"MUSICDEF", 8}, // Kart song definitions
|
||
{"SP_", 3}, // Speedometer changes do not count either.
|
||
{"SC_", 3}, // Colored speedometer stuff too.
|
||
{"SPRTINFO", 8}, // Sprite info
|
||
{"MUSCINFO", 8}, // Music test definitions
|
||
|
||
#ifdef HWRENDER
|
||
{"SHADERS", 7},
|
||
{"SH_", 3},
|
||
#endif
|
||
{NULL, 0},
|
||
};
|
||
|
||
int status = 0;
|
||
|
||
const restype_t type = ResourceFileDetect(filename);
|
||
|
||
if (type == RET_PK3)
|
||
{
|
||
status = W_VerifyPK3(handle, NMUSlist, false);
|
||
}
|
||
else if (type == RET_WAD)
|
||
{
|
||
status = W_VerifyWAD(handle, NMUSlist, false);
|
||
}
|
||
|
||
// repair file handle
|
||
fseek(handle, 0, SEEK_SET);
|
||
|
||
if (status == -1)
|
||
W_InitFileError(filename, exit_on_error);
|
||
|
||
return status;
|
||
}
|
||
|
||
static int W_NameStartsWith(const char *name, lumpchecklist_t *checklist)
|
||
{
|
||
return W_VerifyName(name, checklist, false);
|
||
}
|
||
|
||
// Checks if file contains at least one lump which name starts with one of strings in checklist
|
||
static int W_CheckWADContainsEx(FILE *fp, lumpchecklist_t *checklist, boolean checkmap)
|
||
{
|
||
size_t i, j;
|
||
// if we're here it's a WAD file
|
||
wadinfo_t header;
|
||
filelump_t lumpinfo;
|
||
|
||
// read the header
|
||
if (fread(&header, 1, sizeof header, fp) == sizeof header
|
||
&& header.numlumps < INT16_MAX
|
||
&& strncmp(header.identification, "ZWAD", 4)
|
||
&& strncmp(header.identification, "IWAD", 4)
|
||
&& strncmp(header.identification, "PWAD", 4)
|
||
&& strncmp(header.identification, "SDLL", 4))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
header.numlumps = LONG(header.numlumps);
|
||
header.infotableofs = LONG(header.infotableofs);
|
||
|
||
// let seek to the lumpinfo list
|
||
if (fseek(fp, header.infotableofs, SEEK_SET) == -1)
|
||
return true;
|
||
|
||
for (i = 0; i < header.numlumps; i++)
|
||
{
|
||
// fill in lumpinfo for this wad file directory
|
||
if (fread(&lumpinfo, sizeof (lumpinfo), 1 , fp) != 1)
|
||
return -1;
|
||
|
||
lumpinfo.filepos = LONG(lumpinfo.filepos);
|
||
lumpinfo.size = LONG(lumpinfo.size);
|
||
|
||
if (lumpinfo.size == 0)
|
||
continue;
|
||
|
||
for (j = 0; j < NUMSPRITES; j++)
|
||
if (!strncmp(lumpinfo.name, sprnames[j], 4)) // Sprites
|
||
continue;
|
||
|
||
if (checkmap)
|
||
{
|
||
if (CHECKMAPMARKER(lumpinfo.name))
|
||
return true;
|
||
}
|
||
else if (W_NameStartsWith(lumpinfo.name, checklist))
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
static int W_CheckWADContains(FILE *fp, lumpchecklist_t *checklist)
|
||
{
|
||
return W_CheckWADContainsEx(fp, checklist, false);
|
||
}
|
||
|
||
static int W_CheckWADContainsMap(FILE *fp)
|
||
{
|
||
return W_CheckWADContainsEx(fp, NULL, true);
|
||
}
|
||
|
||
static int W_CheckPK3ContainsEx(FILE *fp, lumpchecklist_t *checklist, boolean checkmap)
|
||
{
|
||
zend_t zend;
|
||
zlentry_t zlentry;
|
||
|
||
long file_size;/* size of zip file */
|
||
long data_size;/* size of data inside zip file */
|
||
|
||
UINT16 numlumps;
|
||
size_t i;
|
||
|
||
char lumpname[9];
|
||
|
||
// Haha the ResGetLumpsZip function doesn't
|
||
// check for file errors, so neither will I.
|
||
|
||
// Central directory bullshit
|
||
|
||
fseek(fp, 0, SEEK_END);
|
||
file_size = ftell(fp);
|
||
|
||
const long startpos = file_size - (22 + 65536);
|
||
if (!ResFindSignature(fp, pat_end, max(0l, startpos)))
|
||
return true;
|
||
|
||
fseek(fp, -4, SEEK_CUR);
|
||
if (fread(&zend, 1, sizeof zend, fp) < sizeof zend)
|
||
return true;
|
||
|
||
data_size = sizeof zend;
|
||
|
||
numlumps = SHORT(zend.entries);
|
||
|
||
fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
|
||
|
||
CLEANUP(pfree) char *cdir = (char *)(malloc(LONG(zend.cdirsize)));
|
||
|
||
if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
size_t offset = 0;
|
||
|
||
for (i = 0; i < numlumps; i++)
|
||
{
|
||
zentry_t *zentry = (zentry_t *)(cdir + offset);
|
||
CLEANUP(pfree) char* fullname = NULL;
|
||
char* trimname;
|
||
char* dotpos;
|
||
|
||
if (memcmp(zentry->signature, pat_central, 4) != 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
|
||
strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
|
||
fullname[zentry->namelen] = 0;
|
||
|
||
// Strip away file address and extension for the 8char name.
|
||
if ((trimname = strrchr(fullname, '/')) != NULL)
|
||
trimname++;
|
||
else
|
||
trimname = fullname; // Care taken for root files.
|
||
|
||
if (*trimname) // Ignore directories, well kinda
|
||
{
|
||
if ((dotpos = strrchr(trimname, '.')) == NULL)
|
||
dotpos = fullname + strlen(fullname); // Watch for files without extension.
|
||
|
||
memset(lumpname, '\0', 9); // Making sure they're initialized to 0. Is it necessary?
|
||
strncpy(lumpname, trimname, min(8, dotpos - trimname));
|
||
|
||
if (checkmap)
|
||
{
|
||
if (CHECKMAPMARKER(lumpname))
|
||
return true;
|
||
}
|
||
else if (W_NameStartsWith(lumpname, checklist))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
if (checkmap)
|
||
{
|
||
if (CHECKMAPMARKER(fullname))
|
||
return true;
|
||
}
|
||
else if (W_NameStartsWith(fullname, checklist))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
offset += sizeof *zentry + SHORT(zentry->namelen) + SHORT(zentry->xtralen) + SHORT(zentry->commlen);
|
||
|
||
data_size +=
|
||
sizeof *zentry + SHORT(zentry->namelen) + SHORT(zentry->xtralen) + SHORT(zentry->commlen);
|
||
|
||
if (fseek(fp, LONG(zentry->offset), SEEK_SET) != 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (fread(&zlentry, 1, sizeof(zlentry_t), fp) < sizeof (zlentry_t))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
data_size +=
|
||
sizeof zlentry + SHORT(zlentry.namelen) + SHORT(zlentry.xtralen) + LONG(zlentry.compsize);
|
||
}
|
||
|
||
if (data_size < file_size)
|
||
{
|
||
const char * error = "ZIP file has holes (%ld extra bytes)\n";
|
||
CONS_Alert(CONS_ERROR, error, (file_size - data_size));
|
||
return -1;
|
||
}
|
||
else if (data_size > file_size)
|
||
{
|
||
const char * error = "Reported size of ZIP file contents exceeds file size (%ld extra bytes)\n";
|
||
CONS_Alert(CONS_ERROR, error, (data_size - file_size));
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
|
||
{
|
||
return W_CheckPK3ContainsEx(fp, checklist, false);
|
||
}
|
||
|
||
static int W_CheckPK3ContainsMap(FILE *fp)
|
||
{
|
||
return W_CheckPK3ContainsEx(fp, NULL, true);
|
||
}
|
||
|
||
static int W_CheckFileContainsEx(const char *filename, lumpchecklist_t *checklist, boolean checkmap)
|
||
{
|
||
FILE *handle;
|
||
int contains = false;
|
||
|
||
// if we just check for maps this will be NULL
|
||
// hacky but i dont care
|
||
if (!checklist && !checkmap)
|
||
I_Error("No checklist for %s\n", filename);
|
||
|
||
// open wad file
|
||
if ((handle = W_OpenWadFile(&filename, false)) == NULL)
|
||
return -1;
|
||
|
||
const restype_t type = ResourceFileDetect(filename);
|
||
|
||
if (type == RET_PK3)
|
||
{
|
||
if (checkmap)
|
||
contains = W_CheckPK3ContainsMap(handle);
|
||
else
|
||
contains = W_CheckPK3Contains(handle, checklist);
|
||
}
|
||
else if (type == RET_WAD)
|
||
{
|
||
if (checkmap)
|
||
contains = W_CheckWADContainsMap(handle);
|
||
else
|
||
contains = W_CheckWADContains(handle, checklist);
|
||
}
|
||
|
||
fclose(handle);
|
||
return contains;
|
||
}
|
||
|
||
static int W_CheckFileContains(const char *filename, lumpchecklist_t *checklist)
|
||
{
|
||
return W_CheckFileContainsEx(filename, checklist, false);
|
||
}
|
||
|
||
static int W_CheckFileContainsMap(const char *filename)
|
||
{
|
||
return W_CheckFileContainsEx(filename, NULL, true);
|
||
}
|
||
|
||
// kinda stupid but we cant just check for any lump containing "MAP"
|
||
// we have to explicitly check if its MAP and 5 characters long
|
||
// the more correct way would be checking inside wad files nested within pk3´s
|
||
// and check the presence of actual map data like SSECTORS or something
|
||
// but man i cannot be assed to rework shit for that
|
||
int W_CheckAutoLoadContainsMap(const char *filename)
|
||
{
|
||
return W_CheckFileContainsMap(filename);
|
||
}
|
||
|
||
int W_CheckPostLoadList(const char *filename)
|
||
{
|
||
static lumpchecklist_t postloadlist[] =
|
||
{
|
||
{"Lua/", 4},
|
||
{"SOC/", 4},
|
||
{"Skins/", 6},
|
||
{"S_SKIN", 6},
|
||
{"LUA_", 4},
|
||
{"SOC_", 4},
|
||
{"MAINCFG", 7},
|
||
{"OBJCTCFG", 8},
|
||
|
||
{NULL, 0},
|
||
};
|
||
|
||
return W_CheckFileContains(filename, postloadlist);
|
||
}
|
||
|
||
/** \brief Generates a virtual resource used for level data loading.
|
||
*
|
||
* \param lumpnum_t reference
|
||
* \return Virtual resource
|
||
*
|
||
*/
|
||
virtres_t* vres_GetMap(lumpnum_t lumpnum)
|
||
{
|
||
UINT32 i;
|
||
virtres_t* vres = NULL;
|
||
virtlump_t* vlumps = NULL;
|
||
size_t numlumps = 0;
|
||
|
||
if (lastloadedmaplumpnum == lumpnum && curmapvirt != NULL)
|
||
{
|
||
// Avoid duplicating all our hard work.
|
||
return curmapvirt;
|
||
}
|
||
|
||
if (W_IsLumpWad(lumpnum))
|
||
{
|
||
UINT32 realentry;
|
||
size_t *vsizecache;
|
||
|
||
// Remember that we're assuming that the WAD will have a specific set of lumps in a specific order.
|
||
UINT8 *wadData = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_LEVEL));
|
||
if (wadData == NULL)
|
||
I_Error("vres_GetMap: Invalid WadData!\n");
|
||
|
||
filelump_t *fileinfo = (filelump_t *)(wadData + LONG(((wadinfo_t *)(wadData))->infotableofs));
|
||
|
||
i = LONG(((wadinfo_t *)(wadData))->numlumps);
|
||
vsizecache = (size_t *)(Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL));
|
||
|
||
for (realentry = 0; realentry < i; realentry++)
|
||
{
|
||
vsizecache[realentry] = (size_t)(LONG(((filelump_t *)(fileinfo + realentry))->size));
|
||
|
||
if (!vsizecache[realentry])
|
||
continue;
|
||
|
||
numlumps++;
|
||
}
|
||
|
||
vlumps = (virtlump_t *)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
|
||
if (vlumps == NULL)
|
||
I_Error("vres_GetMap: Out of memory!\n");
|
||
|
||
// Build the lumps, skipping over empty entries.
|
||
for (i = 0, realentry = 0; i < numlumps; realentry++)
|
||
{
|
||
if (vsizecache[realentry] == 0)
|
||
continue;
|
||
|
||
vlumps[i].size = vsizecache[realentry];
|
||
|
||
const char *name = (fileinfo + realentry)->name;
|
||
I_Assert(name != NULL);
|
||
|
||
if (!name || CHECKMAPMARKER(name))
|
||
{
|
||
numlumps--; // We skip map marker, so 1 of entries becomes empty
|
||
continue; // This will skip i++ so we will write to same entry
|
||
}
|
||
|
||
// Play it safe with the name in this case.
|
||
memcpy(vlumps[i].name, name, 8);
|
||
vlumps[i].name[8] = '\0';
|
||
vlumps[i].data = (UINT8 *)(Z_Malloc(vlumps[i].size, PU_LEVEL, NULL)); // This is memory inefficient, sorry about that.
|
||
memcpy(vlumps[i].data, wadData + LONG((fileinfo + realentry)->filepos), vlumps[i].size);
|
||
i++;
|
||
}
|
||
|
||
Z_Free(vsizecache);
|
||
Z_Free(wadData);
|
||
}
|
||
else
|
||
{
|
||
// Count number of lumps until the end of resource OR up until next 0-length lump OR up until next "MAPXX" lump.
|
||
lumpnum_t lumppos = lumpnum + 1;
|
||
for (i = LUMPNUM(lumppos); i < wadfiles[WADFILENUM(lumpnum)]->numlumps; i++, lumppos++, numlumps++)
|
||
{
|
||
if (W_LumpLength(lumppos) == 0)
|
||
{
|
||
break;
|
||
}
|
||
|
||
const char *name = W_CheckNameForNum(lumppos);
|
||
I_Assert(name != NULL);
|
||
|
||
// if no name then theres no lump
|
||
if (!name || CHECKMAPMARKER(name))
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
numlumps++;
|
||
|
||
vlumps = (virtlump_t *)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
|
||
if (vlumps == NULL)
|
||
I_Error("vres_GetMap: Out of memory!\n");
|
||
|
||
for (i = 0; i < numlumps; i++, lumpnum++)
|
||
{
|
||
// Check if it is map marker. It is not always first lump sadly, so we need to expect it anywhere
|
||
const char *name = W_CheckNameForNum(lumpnum);
|
||
I_Assert(name != NULL);
|
||
|
||
if (!name || CHECKMAPMARKER(name))
|
||
{
|
||
--i; // Decrement so on next iteration we write on same i, so we don't leave corrupted vlumps entry
|
||
numlumps--; // Just so we don't try to access the leftover vlumps entry
|
||
continue;
|
||
}
|
||
|
||
vlumps[i].size = W_LumpLength(lumpnum);
|
||
memcpy(vlumps[i].name, name, 8);
|
||
vlumps[i].name[8] = '\0';
|
||
vlumps[i].data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_LEVEL));
|
||
}
|
||
}
|
||
|
||
vres = (virtres_t *)(Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL));
|
||
vres->vlumps = vlumps;
|
||
vres->numlumps = numlumps;
|
||
|
||
return vres;
|
||
}
|
||
|
||
/** \brief Frees zone memory for a given virtual resource.
|
||
*
|
||
* \param Virtual resource
|
||
*/
|
||
void vres_Free(virtres_t* vres)
|
||
{
|
||
if (vres == curmapvirt)
|
||
{
|
||
// No-sell multiple references.
|
||
return;
|
||
}
|
||
|
||
while (vres->numlumps--)
|
||
{
|
||
Z_Free(vres->vlumps[vres->numlumps].data);
|
||
}
|
||
|
||
Z_Free(vres->vlumps);
|
||
Z_Free(vres);
|
||
}
|
||
|
||
/** (Debug) Prints lumps from a virtual resource into console.
|
||
*/
|
||
/*
|
||
s *tatic void vres_Diag(const virtres_t* vres)
|
||
{
|
||
UINT32 i;
|
||
for (i = 0; i < vres->numlumps; i++)
|
||
CONS_Printf("%s\n", vres->vlumps[i].name);
|
||
}
|
||
*/
|
||
|
||
/** \brief Finds a lump in a given virtual resource.
|
||
*
|
||
* \param Virtual resource
|
||
* \param Lump name to look for
|
||
* \return Virtual lump if found, NULL otherwise
|
||
*
|
||
*/
|
||
virtlump_t* vres_Find(const virtres_t* vres, const char* name)
|
||
{
|
||
UINT32 i;
|
||
for (i = 0; i < vres->numlumps; i++)
|
||
{
|
||
if (fastcmp(name, vres->vlumps[i].name))
|
||
return &vres->vlumps[i];
|
||
}
|
||
|
||
return NULL;
|
||
}
|