Files
SRB2Kart-Saturn/src/w_wad.c
T
alufolie91 8b6ebfbad4 promote those null checks again.....
sigh......
atleast this should be right this time
2026-07-01 22:26:50 +02:00

2856 lines
71 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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;
}